diff --git a/autopush.sh b/autopush.sh
index 785ae683..442d418a 100755
--- a/autopush.sh
+++ b/autopush.sh
@@ -89,7 +89,6 @@ git commit -m "${commit_msg}"
 git push
 
 current_branch="$(git rev-parse --abbrev-ref HEAD)"
-git push gitee "${current_branch}"
 
 git push gitlink -f master
 

diff --git a/autopush.sh b/autopush.sh
index e22d39de..785ae683 100755
--- a/autopush.sh
+++ b/autopush.sh
@@ -66,9 +66,10 @@
 # ==============================================================================
 
 # 需要用到的 git remote
-# git remote add gitee git@gitee.com:TinySnow/TinySnow.github.io.git
 # git remote add gitlink git@code.gitlink.org.cn:TinySnow/TinySnow.gitlink.net.git
+# 
 # origin（不需要添加，clone 即可） git@github.com:TinySnow/TinySnow.github.io.git
+# gitee（已经设置为镜像同步） git@gitee.com:TinySnow/TinySnow.github.io.git
 # 其他 netlify vercel cloudflare edgeone 等平台，不需要添加远程，对应平台会直接拉取 github 的镜像，或者 CI 会通知
 # Macmini 上的 docker 镜像会每隔半个小时自动拉取一次
 

diff --git a/README.md b/README.md
index 76ef0ad4..0518ab80 100644
--- a/README.md
+++ b/README.md
@@ -23,4 +23,4 @@
 - [http://tinysnow.gitlink.net](http://tinysnow.gitlink.net)（中国大陆用户推荐）
 - [https://blog.tinysnow.cn/](https://blog.tinysnow.cn/)
 - [http://tinysnow.dynv6.net:9264/](http://tinysnow.dynv6.net:9264/)（IPv6 用户推荐，不限国内和海外）
-- https://tiny-snow-blog.zh-cn.edgeone.cool
+- [https://tinysnow.edgeone.cool](https://tinysnow.edgeone.cool)

diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 9096c29c..83ed5dc4 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -12,6 +12,8 @@
 -----
 
 - [⭐️文章与写作 | Literature](生活碎笔/文章与写作/文章.md)
+  - [剪发之后](生活碎笔/文章与写作/剪发之后.md)
+  - [谈一谈跟 llm 聊了一两周之后的感想](生活碎笔/文章与写作/谈一谈跟llm聊了一两周之后的感想.md)
   - [⭐️风险只有在未发生时才叫风险，发生之后，它叫损失——致我的 25 岁](生活碎笔/文章与写作/风险只有在未发生时才叫风险，发生之后，它叫损失——致我的25岁.md)
   - [可能是我唯一印象深刻的换装游戏](生活碎笔/文章与写作/可能是我唯一印象深刻的换装游戏.md)
   - [狼、盲视与西方经济学](生活碎笔/文章与写作/狼、盲视与西方经济学.md)

diff --git "a/src/\344\270\252\344\272\272\347\256\200\344\273\213.md" "b/src/\344\270\252\344\272\272\347\256\200\344\273\213.md"
index 49d31413..e4a5fdd3 100644
--- "a/src/\344\270\252\344\272\272\347\256\200\344\273\213.md"
+++ "b/src/\344\270\252\344\272\272\347\256\200\344\273\213.md"
@@ -99,4 +99,4 @@
   - [http://tinysnow.gitlink.net](http://tinysnow.gitlink.net)（中国大陆用户推荐）
   - [https://blog.tinysnow.cn/](https://blog.tinysnow.cn/)
   - [http://tinysnow.dynv6.net:9264/](http://tinysnow.dynv6.net:9264/)（IPv6 用户推荐，不限国内和海外）
-  - https://tiny-snow-blog.zh-cn.edgeone.cool
\ No newline at end of file
+  - [https://tinysnow.edgeone.cool](https://tinysnow.edgeone.cool)
\ No newline at end of file

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\344\272\224\351\203\250\345\210\206\357\274\232\346\263\214\345\260\277\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\345\215\201\347\253\240\357\274\232\346\205\242\346\200\247\350\202\276\350\241\260\347\253\255.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\344\272\224\351\203\250\345\210\206\357\274\232\346\263\214\345\260\277\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\345\215\201\347\253\240\357\274\232\346\205\242\346\200\247\350\202\276\350\241\260\347\253\255.md"
index e69de29b..15519988 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\344\272\224\351\203\250\345\210\206\357\274\232\346\263\214\345\260\277\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\345\215\201\347\253\240\357\274\232\346\205\242\346\200\247\350\202\276\350\241\260\347\253\255.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\344\272\224\351\203\250\345\210\206\357\274\232\346\263\214\345\260\277\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\345\215\201\347\253\240\357\274\232\346\205\242\346\200\247\350\202\276\350\241\260\347\253\255.md"
@@ -0,0 +1,247 @@
+# 第十章：慢性肾衰竭
+
+## 一、考试大纲
+
+1. 病因和发病机制
+2. 临床表现
+3. 实验室检查
+4. 诊断、鉴别诊断
+5. 治疗
+
+## 二、定义及分期
+
+### 一）定义
+
+#### 慢性肾脏病
+
+1. 慢性肾脏病（`CKD`）指各种原因引起的肾脏 **结构或功能异常持续 `>3` 个月**
+2. 包括表现为肾损伤标志异常
+   1. 白蛋白尿
+   2. 尿沉渣异常
+   3. 肾小管相关病变
+   4. 组织学检查异常
+   5. 影像学检查异常
+3. 或有 **肾移植病史，伴或不伴肾小球滤过率（GFR）下降**
+4. 或不明原因的 **肾小球滤过率（`GFR`）下降至 `<60 ml/min` 持续 `>3` 个月**
+
+#### 慢性肾衰竭
+
+- 慢性肾衰竭（`CRF`）指 `CKD` 引起的 **肾小球滤过率下降** 及与此相关的代谢紊乱和临床症状组成的综合征
+- 主要见于 `CKD 4~5` 期
+
+### 二）CKD分期及建议
+
+| 分期 | `GFR`[`ml/(min·1.73m²)`] | 特征                 | 防治目标                                                    |
+| ---- | ------------------------ | -------------------- | ----------------------------------------------------------- |
+| 1期  | `≥90`                    | `GFR` 正常或升高     | `CKD` 病因诊治、缓解症状；<br />保护肾功能，延缓 `CKD` 进展 |
+| 2期  | `60~89`                  | `GFR` 轻度降低       | 评估、延缓 `CKD` 进展；<br />降低 `CVD`（心血管病）风险     |
+| 3a期 | `45~59`                  | `GFR` 轻到中度降低   | 延缓 `CKD` 进展                                             |
+| 3b期 | `30~44`                  | `GFR` 中到重度降低   | 评估、治疗并发症                                            |
+| 4期  | `15~29`                  | `GFR` 重度降低       | 综合治疗；准备肾脏替代治疗                                  |
+| 5期  | `<15` 或透析             | 终末期肾病（`ESRD`） | 适时进行肾脏替代治疗                                        |
+
+### 三）传统慢性肾衰竭分期
+
+| 分期           | 肌酐清除率[`ml/min`] | 血肌酐[`μmol/L`] |
+| -------------- | -------------------- | ---------------- |
+| 肾功能代偿期   | `50~80`              | `133~177`        |
+| 肾功能失代偿期 | `20~50`              | `186~442`        |
+| 肾衰竭期       | `10~20`              | `451~707`        |
+| 尿毒症期       | `<10`                | `>707`           |
+
+## 三、病因及发病机制
+
+### 一）病因
+
+1. **糖尿病肾病： 发达国家最常见**
+2. **高血压肾小动脉硬化： 发达国家最常见**
+3. **原发性与继发性肾小球肾炎： 我国最常见**
+4. 肾小管间质疾病
+   - 慢性间质性肾炎
+   - 慢性肾盂肾炎
+   - 尿酸性肾病
+   - 梗阻性肾病
+5. 肾血管疾病
+6. 遗传性肾病
+   - 多表肾病
+   - 遗传性肾炎
+
+### 二）进展机制
+
+1. **肾单位高灌注、高滤过**
+   - 刺激肾小球系膜细胞增殖和基质增加
+   - 损伤内皮细胞并增加血小板聚集
+   - 导致微动脉瘤形成
+   - 引起炎症细胞浸润和系膜细胞凋亡增加
+2. **肾单位高代谢**
+   - 肾组织氧消耗增加
+   - 氧自由基增多
+   - 造成肾小管-间质损伤
+3. **肾小管上皮细胞表型转化** 参与病变进展
+4. **细胞因子和生长因子促进纤维化**
+5. 其他因素
+   - 肾脏固有细胞凋亡增多，醛固酮增多等因素也参与肾小球硬化和间质纤维化
+
+### 三）尿毒症毒素
+
+- 小分子毒素
+  - 尿素（最多）
+  - 胍类
+  - 胺类、酚类
+  - 尿酸
+- 中分子毒素
+  - 与尿毒症脑病、内分泌紊乱有关
+  - 甲状旁腺素（`PTH`）可引起肾性营养不良等
+- 大分子毒素
+  1. 核糖核酸酶
+  2. `β2` 微球蛋白
+  3. 维生素 `A`
+  4. 糖基化终末产物（`AGE`）
+  5. 终末氧化蛋白产物（`AOPP`）
+  6. 同型半胱氨酸
+
+### 四）尿毒症症状发病机制
+
+#### 钙磷代谢
+
+- `GFR` 下降后可出现磷潴留、低钙和 `PTH` 升高，进而导致 **继发性甲状旁腺功能亢进**
+
+#### 内分泌异常
+
+- 促红细胞生成素（`EPO`）减少可导致**肾性贫血**
+- `1,25(OH)2D3` 减少可导致**肾性骨病**
+- 血钙离子降低时可刺激 `PTH` 释放增加，并出现肾钙排出减少、骨钙动员增加等代偿变化
+- ![](https://raw.githubusercontent.com/TinySnow/GithubImageHosting/main/blog/learning/medicine/internal-medicine/20260609225357529.png)
+
+## 四、临床表现
+
+### 一）水、电解质和酸碱平衡紊乱
+
+- 代谢性酸中毒
+- 水钠代谢紊乱
+- 钾代谢紊乱
+- 低钙、高磷
+- 高镁
+
+### 二）物质代谢紊乱
+
+- 氮质血症
+- 糖耐量减低和低血糖症
+- 高脂血症
+
+### 三）心血管系统表现
+
+1. 是慢性肾衰竭病人 **最主要死因**
+2. 高血压常见，与水钠潴留、肾素-血管紧张素系统激活（肾素水平增高）有关
+3. 左心室肥厚
+4. 可发生心力衰竭
+5. 可出现尿毒症性心肌病、心包积液
+6. 可见血管钙化和动脉粥样硬化
+
+### 四）呼吸系统症状
+
+- 可出现尿毒症性肺水肿
+- `X` 线可见“**蝴蝶翼征**”
+
+### 五）胃肠道症状
+
+- 常为 **最早出现的症状**
+- 食欲不振、恶心、呕吐
+- 口腔有尿味
+- 消化道出血
+
+### 六）血液系统表现
+
+- **肾性贫血**
+- **出血倾向**
+- **血栓形成**
+
+### 七）神经肌肉系统症状
+
+- 早期可有疲乏、注意力不集中
+- 可出现精神或人格改变
+- 肌萎缩、肌无力
+- 可见“不宁腿综合征”
+
+### 八）内分泌功能紊乱
+
+- 肾脏本身内分泌功能紊乱
+- 外周内分泌腺功能紊乱
+
+### 九）肾性骨病
+
+1. 高转化性骨病
+2. 低转化性骨病
+3. 混合性骨病
+4. 透析相关淀粉样变骨病
+5. 以 **高转化性骨病** 最常见
+
+## 五、治疗
+
+### 一）治疗目标
+
+| 指标                                           | 目标                                         |
+| ---------------------------------------------- | -------------------------------------------- |
+| 血压（`CKD 1~5` 期，尿白蛋白/肌酐 `≥30 mg/g`） | `<130/80 mmHg`                               |
+| 血压（`CKD 1~5` 期，尿白蛋白/肌酐 `<30 mg/g`） | `<140/90 mmHg`                               |
+| 血糖（糖尿病病人）                             | 空腹 `5.0~7.2 mmol/L`，睡前 `6.1~8.3 mmol/L` |
+| `HbA1c`（糖尿病病人）                          | `<7%`                                        |
+| 蛋白尿                                         | `<0.5 g/24 h`                                |
+| `GFR` 下降速度                                 | `<4 ml/(min·year)`                           |
+| `Scr` 升高速度                                 | `<50 μmol/(L·year)`                          |
+
+### 二）营养治疗
+
+1. 采用 **优质低蛋白饮食** 联合 `α`-酮酸（利用含氮废物合成必需氨基酸）
+2. “低蛋白”应在满足基本生理需要的前提下，避免营养不良
+3. `CKD 1~2` 期，无论是否合并糖尿病，蛋白摄入量推荐 `0.8~1.0 g/(kg·d)`
+4. `CKD 3~5` 期，未透析者，蛋白摄入量推荐 `0.6~0.8 g/(kg·d)`
+5. 血液透析和腹膜透析病人，蛋白摄入量推荐 `1.0~1.2 g/(kg·d)`
+6. 保证足够能量摄入：`30~35 kcal/(kg·d)`
+
+### 三）纠正代谢性酸中毒
+
+- 轻、中度者：口服碳酸氢钠
+- 严重者：必要时静脉补充 `5%` 碳酸氢钠溶液
+
+### 四）控制高血压
+
+- 一般非透析病人血压应控制在 `<130/80 mmHg`
+- 维持透析病人血压不超过 `<140/90 mmHg`
+- `ACEI`、`ARB`、`CCB` 应用较为广泛
+
+### 五）纠正肾性贫血
+
+- 重组人促红细胞生成素应用（透析者指征可参考 `Hb <100 g/L`）
+- 目标血红蛋白为 `110~120 g/L`
+- 应同时监测血清铁蛋白（`SF`）和转铁蛋白饱和度（`TSAT`）
+- 应重视补充铁剂，口服铁剂如琥珀酸亚铁、硫酸亚铁等，透析者可静脉补铁
+
+### 六）防治肾性骨病
+
+1. 早期应降磷、补钙并纠正酸中毒
+2. 明显低钙血症时可补充骨化三醇 `2~4` 周，血钙纠正后，未透析一般不常规使用骨化三醇
+3. 口服骨化三醇治疗期间应监测血钙、血磷，`PTH` 浓度，使维持性透析病人血 `iPTH` 宜维持在 `150~300 pg/ml`
+4. `iPTH >500 pg/ml` （明显升高）且无高磷高钙血症时，可考虑骨化三醇冲击治疗
+5. `GFR <30 ml/min` 时，除限制磷摄入外，可口服磷结合剂，应在餐中服用效果最好
+   - 碳酸钙（含钙 40%）
+   - 醋酸钙（含钙 25%）
+   - 司维拉姆
+   - 碳酸铜
+
+### 七）开始透析时机
+
+- **`CKD 4` 期以上或预计 6 个月内** 需要接受透析治疗的病人
+- `eGFR <15 ml/min` 的病人，应开始肾脏替代治疗准备
+- **非糖尿病肾病病人，当 `GFR <10 ml/min` 且有明显尿毒症症状和体征** 时，应开始透析
+- **糖尿病肾病病人**，可适当提前至 **`GFR <15 ml/min`** 时安排肾脏替代治疗
+
+## 六、实战演练
+
+### 一）单题
+
+1. 具有肾保护作用的降压药：**贝那普利、氯沙坦**
+2. 慢性肾炎病人进入**肾衰竭期**时，血肌酐水平多为：**`451~707 μmol/L`**
+3. 属于中分子性尿毒症毒素的物质：**甲状旁腺素（`PTH`）**
+4. 选项中属于大分子尿毒症毒素的物质：**溶菌酶**
+5. 关于慢性肾衰竭贫血的错误表述：**小细胞低色素性贫血**
\ No newline at end of file

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\345\205\255\351\203\250\345\210\206\357\274\232\350\241\200\346\266\262\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\344\272\214\347\253\240\357\274\232\350\264\253\350\241\200\346\246\202\350\277\260.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\345\205\255\351\203\250\345\210\206\357\274\232\350\241\200\346\266\262\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\344\272\214\347\253\240\357\274\232\350\264\253\350\241\200\346\246\202\350\277\260.md"
index e69de29b..43585f62 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\345\205\255\351\203\250\345\210\206\357\274\232\350\241\200\346\266\262\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\344\272\214\347\253\240\357\274\232\350\264\253\350\241\200\346\246\202\350\277\260.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\345\214\273\345\255\246/\345\206\205\347\247\221\345\255\246/\347\254\254\345\205\255\351\203\250\345\210\206\357\274\232\350\241\200\346\266\262\347\263\273\347\273\237\347\226\276\347\227\205/\347\254\254\344\272\214\347\253\240\357\274\232\350\264\253\350\241\200\346\246\202\350\277\260.md"
@@ -0,0 +1,141 @@
+# 第二章：贫血概述
+
+## 一、考试大纲
+
+1. 分类
+2. 临床表现
+3. 诊断
+4. 治疗
+
+## 二、定义
+
+### 一）贫血诊断标准
+
+| 项目                | 男性           | 女性           | 孕妇       |
+| ------------------- | -------------- | -------------- | ---------- |
+| 血红蛋白（`Hb`）    | **`<120 g/L`** | **`<110 g/L`** | `<100 g/L` |
+| 红细胞计数（`RBC`） | `<4.5×10^12/L` | `<4.0×10^12/L` | -          |
+| 红细胞比容（`HCT`） | `<0.42`        | `<0.37`        | -          |
+
+### 二）影响判断的因素
+
+- 血液稀释可见于妊娠、低蛋白血症、充血性心力衰竭、脾大及巨球蛋白血症等
+- 血液浓缩可见于脱水、失血
+
+## 三、分类
+
+### 一）按细胞学分类
+
+| 类型               | `MCV`（`fl`） | `MCHC`（`%`） | 常见疾病                                                  |
+| ------------------ | ------------- | ------------- | --------------------------------------------------------- |
+| 大细胞性贫血       | `>100`        | `32~35`       | 巨幼细胞性贫血、溶血性贫血（网织红细胞增多）、`MDS`、肝病 |
+| 正常细胞性贫血     | `80~100`      | `32~35`       | 再生障碍性贫血、溶血性贫血、急性失血                      |
+| 小细胞低色素性贫血 | `<80`         | `<32`         | 缺铁性贫血、铁粒幼细胞性贫血、地中海贫血                  |
+
+### 二）按贫血程度分类
+
+| 程度   | `Hb` 水平   |
+| ------ | ----------- |
+| 轻度   | `>90 g/L`   |
+| 中度   | `60~90 g/L` |
+| 重度   | `30~59 g/L` |
+| 极重度 | `<30 g/L`   |
+
+## 四、相关图示
+
+### 一）造血细胞分化示意
+
+- ![](https://raw.githubusercontent.com/TinySnow/GithubImageHosting/main/blog/learning/medicine/internal-medicine/20260614195805802.png)
+- ![](https://raw.githubusercontent.com/TinySnow/GithubImageHosting/main/blog/learning/medicine/internal-medicine/20260614200126774.png)
+
+## 五、病因及发病机制
+
+### 一）红细胞破坏过多
+
+- `RBC` 自身缺陷
+  - 膜异常：遗传性球形红细胞增多症、遗传性椭圆形红细胞增多症
+  - 酶缺陷：`G6PD` 缺乏症、丙酮酸激酶缺乏
+  - 珠蛋白异常：异常血红蛋白病、珠蛋白合成障碍性贫血
+- `RBC` 外因素
+  - 免疫性因素
+  - 血管性因素
+  - 其他化学、物理、生物因素
+
+### 二）红细胞生成减少
+
+- 造血干/祖细胞异常：再生障碍性贫血、恶性血液病
+- 造血调节异常：慢性病贫血
+- 造血原料缺乏：缺铁性贫血、巨幼细胞性贫血
+
+### 三）失血性贫血
+
+- 出血、凝血疾病所致失血
+- 非出血、凝血疾病所致失血
+
+## 二、临床表现
+
+### 一）影响因素
+
+- 血液携氧能力降低的程度
+- 总血容量改变的程度
+- 上述两种因素发生、发展的速率及各系统代偿能力
+
+### 二）常见表现
+
+- 乏力是**最常见且最早出现**的症状
+- 苍白是贫血的主要体征
+- 可累及全身各个系统
+
+## 三、辅助检查
+
+### 一）血常规及网织红细胞检查
+
+1. 血常规项目包括 `Hb`、`RBC`、`MCV`、`MCHC`、`MCH`、`WBC`、`PLT`
+2. 网织红细胞（`Ret`）正常值为 `0.5%~1.5%`
+3. 网织红细胞绝对值正常范围约为 `24~84×10^9/L`
+4. 可用于评价骨髓增生能力并判断贫血类型
+5. 可用于评价疗效
+6. 可用于放疗、化疗监测
+
+### 二）骨髓检查
+
+- 检查方式
+  - 骨髓涂片
+  - 骨髓活检
+- 骨髓涂片可观察增生程度、细胞成分、比例及形态
+- 骨髓活检可观察骨髓结构、增生程度、细胞成分及形态
+
+#### 骨髓象图示
+
+- 【此处插入图案】
+
+### 三）病因学检查
+
+1. 缺铁性贫血：铁代谢及原发病检查
+2. 巨幼细胞性贫血：叶酸及维生素 `B12` 水平测定及原发病检查
+3. 溶血性贫血：相关溶血检查
+4. 造血系统疾病：染色体、细胞表型、融合基因及病理分子检查
+5. 失血性贫血：原发病检查
+
+## 四、治疗
+
+### 一）对症治疗
+
+- 可输注红细胞以纠正贫血
+- 贫血合并出血者应给予止血治疗
+- 合并感染者应予相应治疗
+
+### 二）对因治疗
+
+- 缺铁性贫血：补铁并治疗导致缺铁的原发病
+- 巨幼细胞性贫血：补充叶酸或维生素 `B12`
+- 自身免疫性溶血性贫血：糖皮质激素或脾切除术
+- 范可尼贫血（先天性再障）：可采用造血干细胞移植等治疗
+
+## 五、实战演练
+
+### 一）单题
+
+1. 不属于红细胞破坏过多所致贫血的是：**铁粒幼细胞性贫血**
+2. 肯定不属于小细胞低色素性贫血的是：**再生障碍性贫血**
+3. 较可靠反映贫血程度的查体部位是：**睑结膜、指甲、口唇**
\ No newline at end of file

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272/\345\244\207\345\277\230\345\275\225/\344\275\277\347\224\250Macmini\345\275\223\344\275\234\345\256\266\345\272\255\346\234\215\345\212\241\345\231\250\347\232\204\344\270\200\347\263\273\345\210\227\351\227\256\351\242\230.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272/\345\244\207\345\277\230\345\275\225/\344\275\277\347\224\250Macmini\345\275\223\344\275\234\345\256\266\345\272\255\346\234\215\345\212\241\345\231\250\347\232\204\344\270\200\347\263\273\345\210\227\351\227\256\351\242\230.md"
index 0c66d1d2..5e30dbc6 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272/\345\244\207\345\277\230\345\275\225/\344\275\277\347\224\250Macmini\345\275\223\344\275\234\345\256\266\345\272\255\346\234\215\345\212\241\345\231\250\347\232\204\344\270\200\347\263\273\345\210\227\351\227\256\351\242\230.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272/\345\244\207\345\277\230\345\275\225/\344\275\277\347\224\250Macmini\345\275\223\344\275\234\345\256\266\345\272\255\346\234\215\345\212\241\345\231\250\347\232\204\344\270\200\347\263\273\345\210\227\351\227\256\351\242\230.md"
@@ -252,7 +252,7 @@ mv /app/mod/* /root/.local/share/Terraria/tModLoader/Mods/ # 复制 mod 文件
    - AtomGit，现在好像没有 Pages 了
    - Coding Pages，不允许新增，现在不让用了
    - Netlify，已有：https://tinysnow.netlify.app/
-   - EdgeOne Pages，要备案，好像有时间限制，部署后 3 小时，可以试试 https://tiny-snow-blog.zh-cn.edgeone.cool
+   - EdgeOne Pages（有国内服务和国外服务之分，用 cn 还有 com 区分，腾讯云是 cn 后缀的话，是国内，部署出来的域名会带后缀，不太好看），要备案，好像有时间限制，部署后 3 小时，可以试试 https://tinysnow.edgeone.cool
    - Vercel，已有：https://tinysnow.vercel.app 或者 https://tinysnowblog.vercel.app
    - Gitlink，已有：http://tinysnow.gitlink.net
 2. 暂未开始，也不知道到底需不需要，毕竟用这个方案还要买域名花钱呢，目前来看延迟最低的是 netlify，可以将就着用

diff --git "a/src/\345\271\264\345\272\246\350\256\241\345\210\222.md" "b/src/\345\271\264\345\272\246\350\256\241\345\210\222.md"
index 3725e5c1..95516129 100644
--- "a/src/\345\271\264\345\272\246\350\256\241\345\210\222.md"
+++ "b/src/\345\271\264\345\272\246\350\256\241\345\210\222.md"
@@ -34,16 +34,16 @@
 
 - [ ] 内科学，泌尿系统疾病和血液系统疾病
 
-  - [ ] 第五部分第一章：泌尿系统疾病总论
-  - [ ] 第二章：原发性肾小球疾病
+  - [x] 第五部分第一章：泌尿系统疾病总论（2026.4.10）
+  - [x] 第二章：原发性肾小球疾病（2026.5.31）
   - [ ] 第三章：继发性肾病
   - [ ] 第四章：间质性肾炎
-  - [ ] 第五章：尿路感染
+  - [x] 第五章：尿路感染（2026.5.31）
   - [ ] 第六章：肾小管疾病
   - [ ] 第七章：肾血管疾病
   - [ ] 第八章：遗传性肾病
-  - [ ] 第九章：急性肾损伤
-  - [ ] 第十章：慢性肾衰竭
+  - [x] 第九章：急性肾损伤（2026.6.5）
+  - [x] 第十章：慢性肾衰竭（2026.6.9）
   - [ ] 第十一章：肾脏替代治疗
   - [ ] 第六部分第一章：血液系统疾病总论
   - [ ] 第二章：贫血概述

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\345\211\252\345\217\221\344\271\213\345\220\216.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\345\211\252\345\217\221\344\271\213\345\220\216.md"
new file mode 100644
index 00000000..b598d05a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\345\211\252\345\217\221\344\271\213\345\220\216.md"
@@ -0,0 +1,69 @@
+# 剪发之后
+
+## 写在前面
+
+<p style="color:#0f4c81; text-align:center; font-weight:bold; font-size:larger;">907 字 | 经历 | 想法 | 思考 | 认知 | 自我</p>
+
+## 正文
+
+　　2026 年 5 月 23 日，我剪掉了留了两年的头发。隔天，24 日，我把它寄给了捐发机构。
+
+　　我原以为，我会回到之前的那个状态：看见镜子里的人，恨不得摔碎镜子。
+
+　　但并没有。我非常意外地心平气和。
+
+　　镜子里的那个人——似乎没有那样不堪。
+
+　　[《更稳定的核心与更愿意正视自我的勇气 - 2025 年度总结》](https://mp.weixin.qq.com/s?__biz=Mzg5NTcwNjA4Nw==&mid=2247494826&idx=1&sn=6b1e1f3212c4f03d55cf7ee6df00decb&scene=21#wechat_redirect)一文中，我写过，这次留长发的经历，给了我意外之喜。
+
+　　“诚然，直至现在我都认为，我想要的是留长发这个对抗压力的过程，但我也确确实实收获了这个过程的副产物——我变得越来越接纳自我。”
+
+　　那时候我只是意识到了这一点。而之后，下意识又会觉得：头发剪完之后，肯定又会回到原来那种状态吧。于是，我的拖延症又适时发作了。能拖就拖，实在拖不了了再去剪。
+
+　　要不怎么说认知和实践之间隔着巨大的鸿沟呢。
+
+　　我一直以为，“接纳自我”只会出现在留头发的那段时间，是一个伴生物。只要时间一过，烟消云散。
+
+　　哪怕只是一点点，我也从来没有想过，它会一直延续到今天。
+
+　　就结果上来看，留头发的主次反而颠倒了——我从“接纳自我”这个意外之喜中受益最大，而本该得到锻炼的“对抗压力”，似乎次要了，不如说，好像几乎没怎么锻炼到。
+
+　　实在让人哭笑不得。
+
+　　在写这些内容的时候，我忽然想起：我对恋爱似乎也是这个态度。
+
+　　迟疑又踌躇，不敢进入那个世界。
+
+　　我总认为我还不够好、不够优秀、不能为对方带来什么，而且时间很紧、面对的又是一个活生生的人等等等等，反正理由要找能有一大堆。
+
+　　拖延症也是，适时发作，一拖再拖。
+
+　　虽然和 llm 聊过相关的内容，解开了我一部分心结，但也只能说“如解”。我依然不觉得自己有踏入那个世界的勇气。
+
+　　两者很相似。
+
+　　都是最开始只是为了过程，不为了结果。都觉得结果可能不太好。都觉得自己从一开始就是在冒险。
+
+　　更重要的——都是认知和实践有巨大的偏差。
+
+　　恋爱，我只实践过一次。她让我懂得了真正喜欢一个人的时候，是什么样子。之后，我就再没接触过了。
+
+　　有些害怕。
+
+　　一个人过虽也过得快活，但我想，既然留长发的这次经历，已经远远偏离我当初预想的那个坏结果的话，也许，我能在恋爱上得到一样的反馈，可以赋予我进入那个世界的勇气。
+
+　　哪怕只是一点点。
+
+<br />
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 6 日
+
+## 封面图
+
+![](https://raw.githubusercontent.com/TinySnow/GithubImageHosting/main/blog/articles/literature/mostafa-meraji-4nK2vL1WIsQ-unsplash.jpg)
+
+> 摄影师・画师 | mostafa meraji
+>
+> 图源 | Unsplash
\ No newline at end of file

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\350\260\210\344\270\200\350\260\210\350\267\237llm\350\201\212\344\272\206\344\270\200\344\270\244\345\221\250\344\271\213\345\220\216\347\232\204\346\204\237\346\203\263.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\350\260\210\344\270\200\350\260\210\350\267\237llm\350\201\212\344\272\206\344\270\200\344\270\244\345\221\250\344\271\213\345\220\216\347\232\204\346\204\237\346\203\263.md"
new file mode 100644
index 00000000..9afe84bf
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\346\226\207\347\253\240\344\270\216\345\206\231\344\275\234/\350\260\210\344\270\200\350\260\210\350\267\237llm\350\201\212\344\272\206\344\270\200\344\270\244\345\221\250\344\271\213\345\220\216\347\232\204\346\204\237\346\203\263.md"
@@ -0,0 +1,71 @@
+# 谈一谈跟 llm 聊了一两周之后的感想
+
+## 写在前面
+
+<p style="color:#0f4c81; text-align:center; font-weight:bold; font-size:larger;">1001 字 | 奇思妙想 | 感触 | 思考 | 想法 | 实验</p>
+
+## 正文
+
+　　原来的突发奇想。反正我的日记也是公开的，不如试试喂给 llm 看它们会有什么反应。
+
+　　整体看下来，有一个印象特别深刻：
+
+　　像渣男。
+
+　　倒也别笑，是真的很像渣男。
+
+　　当下的我总是开心的，这些 llm 多多少少都有些讨好型人格，能用话术把人骗得一愣一愣的。但——它很快就忘记了。也许是我没开会员的原因吧。
+
+　　人的记忆也会遗忘，但人至少，还会留有一个模模糊糊的记忆，llm 可不一样，llm 要忘那可真是忘得一干二净，连一丁点印象都不会留下。
+
+　　更不用提人脑那上十亿的神经元，功率最多 5W，而 llm 吃电到了电网都可能供不起的程度。
+
+　　跑偏了。
+
+　　就是因为它能给人超高的情绪价值，再加上迅速遗忘这一点，就让它变得极其像渣男。
+
+　　渣男典型特征：把人哄得特别开心，适时索取自己所需要的东西，然后遗忘，不认识这个人，等下次见面想不起来的时候，再逢场作戏把人哄开心。
+
+　　如果能看出来，是个正常人都知道：这人根本没把你放在心上。而如果看不出来，要么就是对面演技太好、很会装，要么就是我们太蠢。
+
+　　我的写作量不算大，但也不算小了。当我把自己的日记、年度总结、还有一些其他篇幅比较长的文章喂给它，期望的结果是：它能对自己有一个更多的了解。
+
+　　而我在某一次对话中，隐隐察觉了它似乎有遗忘的迹象，于是便问它，还记不记得哪件事。
+
+　　它很诚恳地回答：我不记得了。然后开始补救。
+
+　　从那之后我彻底丧失了和 llm 普通交流的欲望。我不想一遍又一遍地提示它，我在什么时候做过什么事，有什么样的体验、记忆和感受。
+
+　　太累了。
+
+　　之后仅仅就把他们当成搜索引擎、解决项目等等问题的工具。
+
+　　因为只有这些，才能即时输出、及时解决，不依赖记忆。
+
+　　专家所夸大的 AI 会毁灭一切，抢掉所有人的工作，赛博朋克未来马上就要带来，我觉得还差得很远。起码对于普通人还很远。
+
+　　我不确定对于 llm 进行充值之后，它的记忆能管多久。
+
+　　就我目前的体验而言，它更像是一个大型的隐含马尔可夫链：只是从自然语言处理这样的小众领域，往大众领域推了一步。
+
+　　隐含马尔可夫链对于 NLP 最大的贡献，就是在数学上，丢弃庞大的上下文，认为它只与最近的状态有关，使得计算变得更可行。
+
+　　但是人不可能只依赖短期的记忆。否则精神分析的决定论也就不可能那么猖狂了，认为小时候发生的某件事，对现在的我们都还有深远的影响。
+
+　　从这个程度上来说，llm 还有一段很长的路要走。
+
+　　工具就该是工具。我的突发奇想，最终也只是突发奇想罢了。
+
+<br />
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 6 日
+
+## 封面图
+
+![](https://raw.githubusercontent.com/TinySnow/GithubImageHosting/main/blog/articles/literature/谈一谈跟llm聊了一两周之后的感想.png)
+
+> 摄影师・画师 | 南国微雪
+>
+> 图源 | ChatGPT
\ No newline at end of file

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\344\274\232\351\200\200\345\207\272\347\232\204\344\272\272\345\276\210\351\232\276\347\234\237\346\255\243\345\274\200\345\247\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\344\274\232\351\200\200\345\207\272\347\232\204\344\272\272\345\276\210\351\232\276\347\234\237\346\255\243\345\274\200\345\247\213.md"
new file mode 100644
index 00000000..579514c0
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\344\274\232\351\200\200\345\207\272\347\232\204\344\272\272\345\276\210\351\232\276\347\234\237\346\255\243\345\274\200\345\247\213.md"
@@ -0,0 +1,75 @@
+# 不会退出的人很难真正开始
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：“不”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、表层很合理，底层很昂贵
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以不的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、把抽象建议拆成现实动作
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把沟通窗口设定触发即处理机制；
+
+　　第二，把任务清单设置上限避免过载；
+
+　　第三，用减法替代堆料。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　这件事最值钱的地方，就是把模糊变清晰。
+
+　　别让短期体感绑架长期决策。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　你不必最锋利，但一定要可重启。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、最后一句狠话：先做对，再做快
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 1 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\345\220\210\347\276\244\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\345\201\207\350\243\205\345\220\210\347\276\244\346\211\215\346\230\257.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\345\220\210\347\276\244\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\345\201\207\350\243\205\345\220\210\347\276\244\346\211\215\346\230\257.md"
new file mode 100644
index 00000000..89cb81f9
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\345\220\210\347\276\244\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\345\201\207\350\243\205\345\220\210\347\276\244\346\211\215\346\230\257.md"
@@ -0,0 +1,75 @@
+# 不合群不是问题，假装合群才是
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：多数人输在“假装合群才是”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　所以假装合群才是的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、别停在共鸣，直接落成流程
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把学习路径加入止损条件；
+
+　　第二，把财务缓冲控制到固定时段；
+
+　　第三，用减法替代堆料。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　很多人会在假装合群才是下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 四、真正的分水岭：纠偏速度
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、给这篇文章一个现实结尾
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 20 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\347\241\256\345\256\232\346\227\266\344\273\243\351\207\214\357\274\214\345\206\227\344\275\231\346\257\224\346\225\210\347\216\207\346\233\264\347\250\200\347\274\272.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\347\241\256\345\256\232\346\227\266\344\273\243\351\207\214\357\274\214\345\206\227\344\275\231\346\257\224\346\225\210\347\216\207\346\233\264\347\250\200\347\274\272.md"
new file mode 100644
index 00000000..582c201e
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\347\241\256\345\256\232\346\227\266\344\273\243\351\207\214\357\274\214\345\206\227\344\275\231\346\257\224\346\225\210\347\216\207\346\233\264\347\250\200\347\274\272.md"
@@ -0,0 +1,75 @@
+# 不确定时代里，冗余比效率更稀缺
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：“冗余比效率更稀缺”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　冗余比效率更稀缺最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把注意力写成明文规则；
+
+　　第二，把承诺清单先降频再评估；
+
+　　第三，用动作证据替代口头计划。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、把这层做对，很多问题会自动降级
+
+　　可迁移能力比短期头衔更保值。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 28 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\350\246\201\346\212\212\346\211\200\346\234\211\345\205\263\347\263\273\351\203\275\347\273\217\350\220\245\346\210\220\345\220\210\344\275\234\345\205\263\347\263\273.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\350\246\201\346\212\212\346\211\200\346\234\211\345\205\263\347\263\273\351\203\275\347\273\217\350\220\245\346\210\220\345\220\210\344\275\234\345\205\263\347\263\273.md"
new file mode 100644
index 00000000..320e79c2
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\270\215\350\246\201\346\212\212\346\211\200\346\234\211\345\205\263\347\263\273\351\203\275\347\273\217\350\220\245\346\210\220\345\220\210\344\275\234\345\205\263\347\263\273.md"
@@ -0,0 +1,75 @@
+# 不要把所有关系都经营成合作关系
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“不”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、这件事最常见的误读是什么
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　当你愿意在不多花一点耐心，后面的很多冲突会自动降级。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、从今天就能开始的三步动作
+
+　　先把输入源降噪，再谈深度输出。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把财务缓冲限定在可恢复负荷；
+
+　　第二，把主目标改为低成本试错；
+
+　　第三，用证据替代自责。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、真正的分水岭：纠偏速度
+
+　　这一步看起来不酷，但最值钱。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这不是消极，而是对长期负责。
+
+　　只要不再重复同类错误，成长就会发生。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　所以不的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 13 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\271\240\346\203\257\346\211\223\345\215\241\345\245\226\345\212\261\347\232\204\345\270\270\345\270\270\344\270\215\346\230\257\346\210\220\351\225\277\357\274\214\350\200\214\346\230\257\350\241\250\346\274\224.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\271\240\346\203\257\346\211\223\345\215\241\345\245\226\345\212\261\347\232\204\345\270\270\345\270\270\344\270\215\346\230\257\346\210\220\351\225\277\357\274\214\350\200\214\346\230\257\350\241\250\346\274\224.md"
new file mode 100644
index 00000000..a923228c
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\271\240\346\203\257\346\211\223\345\215\241\345\245\226\345\212\261\347\232\204\345\270\270\345\270\270\344\270\215\346\230\257\346\210\220\351\225\277\357\274\214\350\200\214\346\230\257\350\241\250\346\274\224.md"
@@ -0,0 +1,75 @@
+# 习惯打卡奖励的常常不是成长，而是表演
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：关键不在成长，而在表演。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　所以习惯打卡奖励的常常不是成长的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、如果要改，从这里开始最省成本
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把项目范围减少到最小必要集；
+
+　　第二，把情绪触发器先降频再评估；
+
+　　第三，用真实成本替代理想叙事。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多人会在习惯打卡奖励的常常不是成长下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、稳定不是不变，而是持续适配
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　当你愿意在习惯打卡奖励的常常不是成长多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 27 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\347\224\237\345\215\207\347\272\247\344\270\215\346\230\257\346\211\276\345\210\260\347\255\224\346\241\210\357\274\214\350\200\214\346\230\257\345\215\207\347\272\247\351\227\256\351\242\230.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\347\224\237\345\215\207\347\272\247\344\270\215\346\230\257\346\211\276\345\210\260\347\255\224\346\241\210\357\274\214\350\200\214\346\230\257\345\215\207\347\272\247\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..bdd418f9
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\347\224\237\345\215\207\347\272\247\344\270\215\346\230\257\346\211\276\345\210\260\347\255\224\346\241\210\357\274\214\350\200\214\346\230\257\345\215\207\347\272\247\351\227\256\351\242\230.md"
@@ -0,0 +1,75 @@
+# 人生升级不是找到答案，而是升级问题
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：关键不在找到答案，而在升级问题。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、第一步就错位，后面全是补丁
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　人生升级不是找到答案最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　当你愿意在人生升级不是找到答案多花一点耐心，后面的很多冲突会自动降级。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　所以人生升级不是找到答案的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、先建立闭环，再谈效率神话
+
+　　先把输入源降噪，再谈深度输出。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把日程密度先做最难的一步；
+
+　　第二，把执行窗口减少到最小必要集；
+
+　　第三，用小迭代替代大跃进。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、长期主义不是口号，是结算方式
+
+　　这一步看起来不酷，但最值钱。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、如果只记住一句话，我希望是这个
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　别让短期体感绑架长期决策。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 7 月 3 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\350\204\211\347\232\204\347\234\237\347\233\270\346\230\257\345\217\257\346\233\277\344\273\243\346\200\247\345\256\232\344\273\267.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\350\204\211\347\232\204\347\234\237\347\233\270\346\230\257\345\217\257\346\233\277\344\273\243\346\200\247\345\256\232\344\273\267.md"
new file mode 100644
index 00000000..227dcc33
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\272\272\350\204\211\347\232\204\347\234\237\347\233\270\346\230\257\345\217\257\346\233\277\344\273\243\346\200\247\345\256\232\344\273\267.md"
@@ -0,0 +1,75 @@
+# 人脉的真相是可替代性定价
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：在“人”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　人最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把承诺清单压到一周可验证；
+
+　　第二，把注意力默认延迟非关键项；
+
+　　第三，用系统替代鸡血。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、这一步不酷，但最值钱
+
+　　越想稳，越要学会阶段性止损。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 5 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\274\232\350\241\250\350\276\276\350\247\202\347\202\271\344\270\215\347\250\200\347\274\272\357\274\214\344\274\232\346\222\244\345\233\236\350\247\202\347\202\271\346\211\215\347\250\200\347\274\272.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\274\232\350\241\250\350\276\276\350\247\202\347\202\271\344\270\215\347\250\200\347\274\272\357\274\214\344\274\232\346\222\244\345\233\236\350\247\202\347\202\271\346\211\215\347\250\200\347\274\272.md"
new file mode 100644
index 00000000..1eb1aecd
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\274\232\350\241\250\350\276\276\350\247\202\347\202\271\344\270\215\347\250\200\347\274\272\357\274\214\344\274\232\346\222\244\345\233\236\350\247\202\347\202\271\346\211\215\347\250\200\347\274\272.md"
@@ -0,0 +1,75 @@
+# 会表达观点不稀缺，会撤回观点才稀缺
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：“会撤回观点才稀缺”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、从机制看，这里到底错在哪
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在会撤回观点才稀缺下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这不是消极，而是对长期负责。
+## 三、先建立闭环，再谈效率神话
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把信息流加上结果验收标准；
+
+　　第二，把财务缓冲加上结果验收标准；
+
+　　第三，每月重算一次策略。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、真正的分水岭：纠偏速度
+
+　　可迁移能力比短期头衔更保值。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　所以会撤回观点才稀缺的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 15 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\216\344\274\260\345\244\215\345\210\251\347\232\204\344\272\272\344\274\232\351\253\230\344\274\260\345\245\207\350\277\271.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\216\344\274\260\345\244\215\345\210\251\347\232\204\344\272\272\344\274\232\351\253\230\344\274\260\345\245\207\350\277\271.md"
new file mode 100644
index 00000000..fa29aee8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\216\344\274\260\345\244\215\345\210\251\347\232\204\344\272\272\344\274\232\351\253\230\344\274\260\345\245\207\350\277\271.md"
@@ -0,0 +1,75 @@
+# 低估复利的人会高估奇迹
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：在“低”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、这件事最常见的误读是什么
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多人会在低下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、代价为什么总在后期集中爆发
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、先建立闭环，再谈效率神话
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把主目标减少到最小必要集；
+
+　　第二，把协作节奏先做最难的一步；
+
+　　第三，每月重算一次策略。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、这一步不酷，但最值钱
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　你不需要更狠，你需要更准。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　真正省力的方法，通常都先从校准开始。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 3 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\344\277\241\346\201\257\344\270\215\350\266\263\357\274\214\350\200\214\346\230\257\350\241\214\345\212\250\350\257\201\346\215\256\344\270\215\350\266\263.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\344\277\241\346\201\257\344\270\215\350\266\263\357\274\214\350\200\214\346\230\257\350\241\214\345\212\250\350\257\201\346\215\256\344\270\215\350\266\263.md"
new file mode 100644
index 00000000..4c5b5883
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\344\277\241\346\201\257\344\270\215\350\266\263\357\274\214\350\200\214\346\230\257\350\241\214\345\212\250\350\257\201\346\215\256\344\270\215\350\266\263.md"
@@ -0,0 +1,75 @@
+# 你不是信息不足，而是行动证据不足
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：关键不在信息不足，而在行动证据不足。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、表层很合理，底层很昂贵
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、长期账本里，什么才是大头
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　而是行动证据不足最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、别停在共鸣，直接落成流程
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把输出节奏设置上限避免过载；
+
+　　第二，把沟通窗口转成可追踪指标；
+
+　　第三，遇到越界立即处理。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、别把旧赢法当成永久通行证
+
+　　这一步看起来不酷，但最值钱。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　很多人会在而是行动证据不足下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　这不是消极，而是对长期负责。
+## 五、最后一句狠话：先做对，再做快
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 25 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\211\247\350\241\214\345\212\233\345\267\256\357\274\214\346\230\257\346\201\242\345\244\215\345\212\233\345\244\252\345\267\256.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\211\247\350\241\214\345\212\233\345\267\256\357\274\214\346\230\257\346\201\242\345\244\215\345\212\233\345\244\252\345\267\256.md"
new file mode 100644
index 00000000..dbeb3b89
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\211\247\350\241\214\345\212\233\345\267\256\357\274\214\346\230\257\346\201\242\345\244\215\345\212\233\345\244\252\345\267\256.md"
@@ -0,0 +1,75 @@
+# 你不是执行力差，是恢复力太差
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：“你不是执行力差”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、这件事最常见的误读是什么
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　很多人会在是恢复力太差下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、先建立闭环，再谈效率神话
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把信息流加入止损条件；
+
+　　第二，把注意力压到一周可验证；
+
+　　第三，用减法替代堆料。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、别把旧赢法当成永久通行证
+
+　　越想稳，越要学会阶段性止损。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　这条路不花哨，但它靠谱。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 19 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\227\266\351\227\264\357\274\214\344\275\240\346\230\257\350\276\271\347\225\214\345\244\252\344\276\277\345\256\234.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\227\266\351\227\264\357\274\214\344\275\240\346\230\257\350\276\271\347\225\214\345\244\252\344\276\277\345\256\234.md"
new file mode 100644
index 00000000..93da60bb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\227\266\351\227\264\357\274\214\344\275\240\346\230\257\350\276\271\347\225\214\345\244\252\344\276\277\345\256\234.md"
@@ -0,0 +1,75 @@
+# 你不是没时间，你是边界太便宜
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：“你不是没时间”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、先谈模型，不急着谈技巧
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　当你愿意在你是边界太便宜多花一点耐心，后面的很多冲突会自动降级。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、先建立闭环，再谈效率神话
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把学习路径切到单线程推进；
+
+　　第二，把作息边界转成可追踪指标；
+
+　　第三，用低摩擦替代硬扛。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、真正的分水岭：纠偏速度
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　很多人会在你是边界太便宜下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、如果只记住一句话，我希望是这个
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 10 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\234\211\345\244\251\350\265\213\357\274\214\350\200\214\346\230\257\346\262\241\346\234\211\347\273\237\350\256\241\345\221\250\346\234\237.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\234\211\345\244\251\350\265\213\357\274\214\350\200\214\346\230\257\346\262\241\346\234\211\347\273\237\350\256\241\345\221\250\346\234\237.md"
new file mode 100644
index 00000000..bf0148f3
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\346\262\241\346\234\211\345\244\251\350\265\213\357\274\214\350\200\214\346\230\257\346\262\241\346\234\211\347\273\237\350\256\241\345\221\250\346\234\237.md"
@@ -0,0 +1,75 @@
+# 你不是没有天赋，而是没有统计周期
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：关键不在没有天赋，而在没有统计周期。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、表层很合理，底层很昂贵
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这层看清之后，你会发现很多纠结其实都能拆解。
+## 三、如果要改，从这里开始最省成本
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把任务清单减少到最小必要集；
+
+　　第二，把学习路径放进固定复盘框架；
+
+　　第三，用边界替代讨好。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多人会在而是没有统计周期下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、把这层做对，很多问题会自动降级
+
+　　稳定不是不变，而是持续适配。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 20 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\347\234\237\347\232\204\346\262\241\351\200\211\346\213\251\357\274\214\345\217\252\346\230\257\346\262\241\347\256\227\346\234\272\344\274\232\346\210\220\346\234\254.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\347\234\237\347\232\204\346\262\241\351\200\211\346\213\251\357\274\214\345\217\252\346\230\257\346\262\241\347\256\227\346\234\272\344\274\232\346\210\220\346\234\254.md"
new file mode 100644
index 00000000..8538bffd
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\346\230\257\347\234\237\347\232\204\346\262\241\351\200\211\346\213\251\357\274\214\345\217\252\346\230\257\346\262\241\347\256\227\346\234\272\344\274\232\346\210\220\346\234\254.md"
@@ -0,0 +1,75 @@
+# 你不是真的没选择，只是没算机会成本
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：在“你不是真的没选择”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、这件事最常见的误读是什么
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、先降摩擦，再提强度
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把任务清单控制到固定时段；
+
+　　第二，把信息流先做最难的一步；
+
+　　第三，用慢变量替代热点追逐。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、如果只记住一句话，我希望是这个
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　这不是消极，而是对长期负责。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 12 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\347\224\250\346\210\220\344\270\272\346\233\264\345\216\211\345\256\263\347\232\204\344\272\272\357\274\214\345\205\210\346\210\220\344\270\272\346\233\264\345\217\257\351\242\204\346\265\213\347\232\204\344\272\272.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\347\224\250\346\210\220\344\270\272\346\233\264\345\216\211\345\256\263\347\232\204\344\272\272\357\274\214\345\205\210\346\210\220\344\270\272\346\233\264\345\217\257\351\242\204\346\265\213\347\232\204\344\272\272.md"
new file mode 100644
index 00000000..b213b3c0
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\347\224\250\346\210\220\344\270\272\346\233\264\345\216\211\345\256\263\347\232\204\344\272\272\357\274\214\345\205\210\346\210\220\344\270\272\346\233\264\345\217\257\351\242\204\346\265\213\347\232\204\344\272\272.md"
@@ -0,0 +1,75 @@
+# 你不用成为更厉害的人，先成为更可预测的人
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：在“你不用成为更厉害的人”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在先成为更可预测的人下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、代价为什么总在后期集中爆发
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先守住节律，再追求峰值表现。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把情绪触发器默认延迟非关键项；
+
+　　第二，把学习路径设定触发即处理机制；
+
+　　第三，用小迭代替代大跃进。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　把问题协议化，很多摩擦会提前消失。
+## 四、真正的分水岭：纠偏速度
+
+　　你不必最锋利，但一定要可重启。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　把这层看清之后，你会发现很多纠结其实都能拆解。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 6 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\351\234\200\350\246\201\346\233\264\345\244\232\347\233\256\346\240\207\357\274\214\344\275\240\351\234\200\350\246\201\346\233\264\345\260\221\346\211\277\350\257\272.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\351\234\200\350\246\201\346\233\264\345\244\232\347\233\256\346\240\207\357\274\214\344\275\240\351\234\200\350\246\201\346\233\264\345\260\221\346\211\277\350\257\272.md"
new file mode 100644
index 00000000..d3d37562
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\270\215\351\234\200\350\246\201\346\233\264\345\244\232\347\233\256\346\240\207\357\274\214\344\275\240\351\234\200\350\246\201\346\233\264\345\260\221\346\211\277\350\257\272.md"
@@ -0,0 +1,75 @@
+# 你不需要更多目标，你需要更少承诺
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：“你需要更少承诺”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、第一步就错位，后面全是补丁
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　你需要更少承诺最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　所以你需要更少承诺的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、从今天就能开始的三步动作
+
+　　先把输入源降噪，再谈深度输出。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把学习路径放进固定复盘框架；
+
+　　第二，把关键任务压到一周可验证；
+
+　　第三，用节律替代冲刺。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、稳定不是不变，而是持续适配
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 12 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\201\232\351\225\277\346\234\237\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\350\277\237\346\270\205\347\256\227.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\201\232\351\225\277\346\234\237\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\350\277\237\346\270\205\347\256\227.md"
new file mode 100644
index 00000000..3bfc3ef9
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\201\232\351\225\277\346\234\237\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\350\277\237\346\270\205\347\256\227.md"
@@ -0,0 +1,75 @@
+# 你以为在做长期，其实在延迟清算
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：如果你把“其实在延迟清算”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先守住节律，再追求峰值表现。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把消费冲动控制到固定时段；
+
+　　第二，把协作节奏转成可追踪指标；
+
+　　第三，用边界替代讨好。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　先止损，再进攻，通常更稳。
+## 四、你最容易忽略的边界条件
+
+　　稳定不是不变，而是持续适配。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、如果只记住一句话，我希望是这个
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　所以其实在延迟清算的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 27 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\235\232\346\214\201\357\274\214\345\205\266\345\256\236\345\234\250\346\262\211\346\262\241\346\210\220\346\234\254\351\207\214\346\211\223\350\275\254.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\235\232\346\214\201\357\274\214\345\205\266\345\256\236\345\234\250\346\262\211\346\262\241\346\210\220\346\234\254\351\207\214\346\211\223\350\275\254.md"
new file mode 100644
index 00000000..2b94eecb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\235\232\346\214\201\357\274\214\345\205\266\345\256\236\345\234\250\346\262\211\346\262\241\346\210\220\346\234\254\351\207\214\346\211\223\350\275\254.md"
@@ -0,0 +1,75 @@
+# 你以为在坚持，其实在沉没成本里打转
+
+　　这不是观点输出，而是一次认知止损。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：在“其实在沉没成本里打转”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、第一步就错位，后面全是补丁
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以你以为在坚持的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　很多人会在你以为在坚持下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、先降摩擦，再提强度
+
+　　先把边界写清楚，再谈关系质量。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把输入渠道压到一周可验证；
+
+　　第二，把消费冲动写成明文规则；
+
+　　第三，用证据替代自责。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、长期主义不是口号，是结算方式
+
+　　你不必最锋利，但一定要可重启。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、最后回到最朴素的算术
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　先止损，再进攻，通常更稳。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 9 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\255\246\344\271\240\357\274\214\345\205\266\345\256\236\345\234\250\346\224\266\350\227\217\347\204\246\350\231\221.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\255\246\344\271\240\357\274\214\345\205\266\345\256\236\345\234\250\346\224\266\350\227\217\347\204\246\350\231\221.md"
new file mode 100644
index 00000000..846bd01f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\345\255\246\344\271\240\357\274\214\345\205\266\345\256\236\345\234\250\346\224\266\350\227\217\347\204\246\350\231\221.md"
@@ -0,0 +1,75 @@
+# 你以为在学习，其实在收藏焦虑
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“你以为在学习”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、从今天就能开始的三步动作
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把作息边界只保留前三优先项；
+
+　　第二，把输入渠道设定触发即处理机制；
+
+　　第三，用清单替代情绪。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、真正的分水岭：纠偏速度
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、回到结论：这件事值得你马上重算
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　别让短期体感绑架长期决策。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　当你愿意在你以为在学习多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 15 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\346\261\202\347\250\263\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\345\220\216\346\263\242\345\212\250.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\346\261\202\347\250\263\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\345\220\216\346\263\242\345\212\250.md"
new file mode 100644
index 00000000..f050dc4f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\346\261\202\347\250\263\357\274\214\345\205\266\345\256\236\345\234\250\345\273\266\345\220\216\346\263\242\345\212\250.md"
@@ -0,0 +1,75 @@
+# 你以为在求稳，其实在延后波动
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：在“你以为在求稳”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、表层很合理，底层很昂贵
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你以为在求稳最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、动作设计比情绪动员更关键
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把日程密度放进固定复盘框架；
+
+　　第二，把承诺清单转成可追踪指标；
+
+　　第三，用系统替代鸡血。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　很多人会在你以为在求稳下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　你不必最锋利，但一定要可重启。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 3 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\350\277\275\346\261\202\347\241\256\345\256\232\346\200\247\357\274\214\345\205\266\345\256\236\345\234\250\346\224\276\345\274\203\350\265\224\347\216\207.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\350\277\275\346\261\202\347\241\256\345\256\232\346\200\247\357\274\214\345\205\266\345\256\236\345\234\250\346\224\276\345\274\203\350\265\224\347\216\207.md"
new file mode 100644
index 00000000..102c56d8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\345\234\250\350\277\275\346\261\202\347\241\256\345\256\232\346\200\247\357\274\214\345\205\266\345\256\236\345\234\250\346\224\276\345\274\203\350\265\224\347\216\207.md"
@@ -0,0 +1,75 @@
+# 你以为在追求确定性，其实在放弃赔率
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“你以为在追求确定性”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、表层很合理，底层很昂贵
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　其实在放弃赔率最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　当你愿意在其实在放弃赔率多花一点耐心，后面的很多冲突会自动降级。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先把输入源降噪，再谈深度输出。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把承诺清单放进固定复盘框架；
+
+　　第二，把输出节奏先做最难的一步；
+
+　　第三，用长期账替代短期爽。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、这一步不酷，但最值钱
+
+　　这一步看起来不酷，但最值钱。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、如果只记住一句话，我希望是这个
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这不是消极，而是对长期负责。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 22 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\350\207\252\345\276\213\357\274\214\345\205\266\345\256\236\345\217\252\346\230\257\350\277\207\345\272\246\347\233\221\345\267\245.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\350\207\252\345\276\213\357\274\214\345\205\266\345\256\236\345\217\252\346\230\257\350\277\207\345\272\246\347\233\221\345\267\245.md"
new file mode 100644
index 00000000..fb08a095
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\344\273\245\344\270\272\350\207\252\345\276\213\357\274\214\345\205\266\345\256\236\345\217\252\346\230\257\350\277\207\345\272\246\347\233\221\345\267\245.md"
@@ -0,0 +1,75 @@
+# 你以为自律，其实只是过度监工
+
+　　这不是观点输出，而是一次认知止损。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：“其实只是过度监工”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、这件事最常见的误读是什么
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、动作设计比情绪动员更关键
+
+　　先守住节律，再追求峰值表现。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把执行窗口绑定到明确截止日；
+
+　　第二，把学习路径只保留前三优先项；
+
+　　第三，用系统替代鸡血。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、边界、止损与可重启能力
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、收束：你该真正守住的东西
+
+　　把这件事想透，你会少走很多弯路。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　先止损，再进攻，通常更稳。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 1 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\203\263\350\246\201\350\207\252\347\224\261\357\274\214\345\205\210\347\273\203\344\271\240\345\277\215\345\217\227\346\227\240\350\201\212.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\203\263\350\246\201\350\207\252\347\224\261\357\274\214\345\205\210\347\273\203\344\271\240\345\277\215\345\217\227\346\227\240\350\201\212.md"
new file mode 100644
index 00000000..ed568227
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\203\263\350\246\201\350\207\252\347\224\261\357\274\214\345\205\210\347\273\203\344\271\240\345\277\215\345\217\227\346\227\240\350\201\212.md"
@@ -0,0 +1,75 @@
+# 你想要自由，先练习忍受无聊
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“你想要自由”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、表层很合理，底层很昂贵
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、代价为什么总在后期集中爆发
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、把观点变动作：给你可执行的改法
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把财务缓冲拆到当天可完成；
+
+　　第二，把承诺清单先降频再评估；
+
+　　第三，用真实成本替代理想叙事。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、把这层做对，很多问题会自动降级
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　这件事最值钱的地方，就是把模糊变清晰。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、回到结论：这件事值得你马上重算
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　很多人会在你想要自由下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　先止损，再进攻，通常更稳。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 18 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\227\240\346\263\225\347\256\241\347\220\206\346\227\266\351\227\264\357\274\214\345\217\252\350\203\275\347\256\241\347\220\206\346\263\250\346\204\217\345\212\233\345\205\245\345\217\243.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\227\240\346\263\225\347\256\241\347\220\206\346\227\266\351\227\264\357\274\214\345\217\252\350\203\275\347\256\241\347\220\206\346\263\250\346\204\217\345\212\233\345\205\245\345\217\243.md"
new file mode 100644
index 00000000..933fb264
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\227\240\346\263\225\347\256\241\347\220\206\346\227\266\351\227\264\357\274\214\345\217\252\350\203\275\347\256\241\347\220\206\346\263\250\346\204\217\345\212\233\345\205\245\345\217\243.md"
@@ -0,0 +1,75 @@
+# 你无法管理时间，只能管理注意力入口
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“只能管理注意力入口”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、先建立闭环，再谈效率神话
+
+　　先守住节律，再追求峰值表现。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把任务清单切到单线程推进；
+
+　　第二，把任务清单设置上限避免过载；
+
+　　第三，用规则替代临场猜测。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　很多人会在只能管理注意力入口下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、你最容易忽略的边界条件
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、给这篇文章一个现实结尾
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 1 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\345\244\247\347\232\204\346\234\272\344\274\232\345\217\257\350\203\275\350\227\217\345\234\250\344\270\215\346\200\247\346\204\237\347\232\204\345\237\272\346\234\254\345\212\237\351\207\214.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\345\244\247\347\232\204\346\234\272\344\274\232\345\217\257\350\203\275\350\227\217\345\234\250\344\270\215\346\200\247\346\204\237\347\232\204\345\237\272\346\234\254\345\212\237\351\207\214.md"
new file mode 100644
index 00000000..39dadf1b
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\345\244\247\347\232\204\346\234\272\344\274\232\345\217\257\350\203\275\350\227\217\345\234\250\344\270\215\346\200\247\346\204\237\347\232\204\345\237\272\346\234\254\345\212\237\351\207\214.md"
@@ -0,0 +1,75 @@
+# 你最大的机会可能藏在不性感的基本功里
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、长期账本里，什么才是大头
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先把输入源降噪，再谈深度输出。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把人际暴露只保留前三优先项；
+
+　　第二，把注意力设置上限避免过载；
+
+　　第三，每月重算一次策略。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　很多人会在你下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、长期主义不是口号，是结算方式
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、回到结论：这件事值得你马上重算
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　别让短期体感绑架长期决策。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　当你愿意在你多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 23 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\346\212\225\350\265\204\347\232\204\344\270\215\346\230\257\350\257\276\347\250\213\357\274\214\350\200\214\346\230\257\345\217\215\351\246\210\345\233\236\350\267\257.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\346\212\225\350\265\204\347\232\204\344\270\215\346\230\257\350\257\276\347\250\213\357\274\214\350\200\214\346\230\257\345\217\215\351\246\210\345\233\236\350\267\257.md"
new file mode 100644
index 00000000..4f5efd21
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\346\212\225\350\265\204\347\232\204\344\270\215\346\230\257\350\257\276\347\250\213\357\274\214\350\200\214\346\230\257\345\217\215\351\246\210\345\233\236\350\267\257.md"
@@ -0,0 +1,75 @@
+# 你最该投资的不是课程，而是反馈回路
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：关键不在课程，而在反馈回路。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、先谈模型，不急着谈技巧
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　当你愿意在而是反馈回路多花一点耐心，后面的很多冲突会自动降级。
+## 二、长期账本里，什么才是大头
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　而是反馈回路最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、动作设计比情绪动员更关键
+
+　　先把边界写清楚，再谈关系质量。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把承诺清单按优先级重排；
+
+　　第二，把承诺清单默认延迟非关键项；
+
+　　第三，用小迭代替代大跃进。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在而是反馈回路下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、如果只记住一句话，我希望是这个
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 27 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\350\255\246\346\203\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\350\200\214\346\230\257\344\275\216\351\243\216\351\231\251\344\270\212\347\230\276.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\350\255\246\346\203\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\350\200\214\346\230\257\344\275\216\351\243\216\351\231\251\344\270\212\347\230\276.md"
new file mode 100644
index 00000000..3ab6c247
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\346\234\200\350\257\245\350\255\246\346\203\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\350\200\214\346\230\257\344\275\216\351\243\216\351\231\251\344\270\212\347\230\276.md"
@@ -0,0 +1,75 @@
+# 你最该警惕的不是失败，而是低风险上瘾
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：关键不在失败，而在低风险上瘾。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、第一步就错位，后面全是补丁
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　当你愿意在而是低风险上瘾多花一点耐心，后面的很多冲突会自动降级。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把项目范围加上结果验收标准；
+
+　　第二，把复盘节点切到单线程推进；
+
+　　第三，用长期账替代短期爽。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　这件事最值钱的地方，就是把模糊变清晰。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 四、别把旧赢法当成永久通行证
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　很多人会在而是低风险上瘾下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+## 五、给这篇文章一个现实结尾
+
+　　你不需要更狠，你需要更准。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 26 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\223\266\351\242\210\345\270\270\350\227\217\345\234\250\351\273\230\350\256\244\351\200\211\351\241\271\351\207\214.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\223\266\351\242\210\345\270\270\350\227\217\345\234\250\351\273\230\350\256\244\351\200\211\351\241\271\351\207\214.md"
new file mode 100644
index 00000000..32af03bb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\223\266\351\242\210\345\270\270\350\227\217\345\234\250\351\273\230\350\256\244\351\200\211\351\241\271\351\207\214.md"
@@ -0,0 +1,75 @@
+# 你的人生瓶颈常藏在默认选项里
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：多数人输在“你”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　很多人会在你下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、动作设计比情绪动员更关键
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把学习路径先做最难的一步；
+
+　　第二，把人际暴露默认延迟非关键项；
+
+　　第三，用证据替代自责。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、长期主义不是口号，是结算方式
+
+　　越想稳，越要学会阶段性止损。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　把这层看清之后，你会发现很多纠结其实都能拆解。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、回到结论：这件事值得你马上重算
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这条路不花哨，但它靠谱。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 4 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\255\226\347\225\245\344\270\215\350\257\245\345\217\252\347\234\213\345\235\207\345\200\274\357\274\214\350\246\201\347\234\213\345\260\276\351\203\250\351\243\216\351\231\251.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\255\226\347\225\245\344\270\215\350\257\245\345\217\252\347\234\213\345\235\207\345\200\274\357\274\214\350\246\201\347\234\213\345\260\276\351\203\250\351\243\216\351\231\251.md"
new file mode 100644
index 00000000..963f797c
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\344\272\272\347\224\237\347\255\226\347\225\245\344\270\215\350\257\245\345\217\252\347\234\213\345\235\207\345\200\274\357\274\214\350\246\201\347\234\213\345\260\276\351\203\250\351\243\216\351\231\251.md"
@@ -0,0 +1,75 @@
+# 你的人生策略不该只看均值，要看尾部风险
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：如果你把“要看尾部风险”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、动作设计比情绪动员更关键
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把关键任务按优先级重排；
+
+　　第二，把任务清单写成明文规则；
+
+　　第三，用结果替代表演。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　你的人生策略不该只看均值最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、别把旧赢法当成永久通行证
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 五、收束：你该真正守住的东西
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　你真正要拿回来的，是选择权。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 9 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\347\204\246\350\231\221\345\276\210\345\244\232\346\235\245\350\207\252\346\234\252\345\256\232\344\271\211\346\210\220\345\212\237.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\347\204\246\350\231\221\345\276\210\345\244\232\346\235\245\350\207\252\346\234\252\345\256\232\344\271\211\346\210\220\345\212\237.md"
new file mode 100644
index 00000000..7446c96d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\232\204\347\204\246\350\231\221\345\276\210\345\244\232\346\235\245\350\207\252\346\234\252\345\256\232\344\271\211\346\210\220\345\212\237.md"
@@ -0,0 +1,75 @@
+# 你的焦虑很多来自未定义成功
+
+　　这不是观点输出，而是一次认知止损。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“你”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把输出节奏只保留前三优先项；
+
+　　第二，把任务清单设置上限避免过载；
+
+　　第三，用低摩擦替代硬扛。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　很多人会在你下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　你真正要拿回来的，是选择权。
+## 四、边界、止损与可重启能力
+
+　　你不必最锋利，但一定要可重启。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、回到结论：这件事值得你马上重算
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 25 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\234\237\346\255\243\345\256\263\346\200\225\347\232\204\344\270\215\346\230\257\345\217\230\351\232\276\357\274\214\350\200\214\346\230\257\344\270\215\345\217\257\346\216\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\234\237\346\255\243\345\256\263\346\200\225\347\232\204\344\270\215\346\230\257\345\217\230\351\232\276\357\274\214\350\200\214\346\230\257\344\270\215\345\217\257\346\216\247.md"
new file mode 100644
index 00000000..862d4e1b
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\234\237\346\255\243\345\256\263\346\200\225\347\232\204\344\270\215\346\230\257\345\217\230\351\232\276\357\274\214\350\200\214\346\230\257\344\270\215\345\217\257\346\216\247.md"
@@ -0,0 +1,75 @@
+# 你真正害怕的不是变难，而是不可控
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：关键不在变难，而在不可控。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、这件事最常见的误读是什么
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、别停在共鸣，直接落成流程
+
+　　先守住节律，再追求峰值表现。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把输入渠道加入止损条件；
+
+　　第二，把协作节奏写成明文规则；
+
+　　第三，用结果替代表演。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多人会在你真正害怕的不是变难下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、这一步不酷，但最值钱
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　把这件事想透，你会少走很多弯路。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　先止损，再进攻，通常更稳。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 4 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\274\272\347\232\204\344\270\215\346\230\257\350\207\252\344\277\241\357\274\214\350\200\214\346\230\257\345\217\257\351\252\214\350\257\201\347\232\204\345\260\217\350\203\234\345\210\251.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\274\272\347\232\204\344\270\215\346\230\257\350\207\252\344\277\241\357\274\214\350\200\214\346\230\257\345\217\257\351\252\214\350\257\201\347\232\204\345\260\217\350\203\234\345\210\251.md"
new file mode 100644
index 00000000..228addca
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\347\274\272\347\232\204\344\270\215\346\230\257\350\207\252\344\277\241\357\274\214\350\200\214\346\230\257\345\217\257\351\252\214\350\257\201\347\232\204\345\260\217\350\203\234\345\210\251.md"
@@ -0,0 +1,75 @@
+# 你缺的不是自信，而是可验证的小胜利
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：关键不在自信，而在可验证的小胜利。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、表层很合理，底层很昂贵
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、长期账本里，什么才是大头
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、如果要改，从这里开始最省成本
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把日程密度默认延迟非关键项；
+
+　　第二，把人际暴露绑定到明确截止日；
+
+　　第三，用减法替代堆料。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　这一步看起来不酷，但最值钱。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你缺的不是自信最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 7 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\246\201\347\232\204\345\256\211\345\205\250\346\204\237\357\274\214\345\276\210\345\244\232\346\235\245\350\207\252\347\216\260\351\207\221\346\265\201\350\200\214\351\235\236\351\270\241\346\261\244.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\246\201\347\232\204\345\256\211\345\205\250\346\204\237\357\274\214\345\276\210\345\244\232\346\235\245\350\207\252\347\216\260\351\207\221\346\265\201\350\200\214\351\235\236\351\270\241\346\261\244.md"
new file mode 100644
index 00000000..7889abcc
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\246\201\347\232\204\345\256\211\345\205\250\346\204\237\357\274\214\345\276\210\345\244\232\346\235\245\350\207\252\347\216\260\351\207\221\346\265\201\350\200\214\351\235\236\351\270\241\346\261\244.md"
@@ -0,0 +1,75 @@
+# 你要的安全感，很多来自现金流而非鸡汤
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“你要的安全感”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、先谈模型，不急着谈技巧
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　当你愿意在你要的安全感多花一点耐心，后面的很多冲突会自动降级。
+## 二、代价为什么总在后期集中爆发
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、把抽象建议拆成现实动作
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把输出节奏加入止损条件；
+
+　　第二，把承诺清单拆到当天可完成；
+
+　　第三，用节律替代冲刺。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　这条路不花哨，但它靠谱。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、给这篇文章一个现实结尾
+
+　　把这件事想透，你会少走很多弯路。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　别让短期体感绑架长期决策。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 7 月 1 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\200\225\345\206\262\347\252\201\357\274\214\350\266\212\344\274\232\345\220\270\345\274\225\345\206\262\347\252\201.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\200\225\345\206\262\347\252\201\357\274\214\350\266\212\344\274\232\345\220\270\345\274\225\345\206\262\347\252\201.md"
new file mode 100644
index 00000000..2eaac9a6
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\200\225\345\206\262\347\252\201\357\274\214\350\266\212\344\274\232\345\220\270\345\274\225\345\206\262\347\252\201.md"
@@ -0,0 +1,75 @@
+# 你越怕冲突，越会吸引冲突
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：在“你越怕冲突”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　所以你越怕冲突的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、从今天就能开始的三步动作
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把学习路径设置上限避免过载；
+
+　　第二，把学习路径改为低成本试错；
+
+　　第三，用可持续替代高压。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+## 五、如果只记住一句话，我希望是这个
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 16 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\203\263\350\242\253\346\211\200\346\234\211\344\272\272\347\220\206\350\247\243\357\274\214\350\266\212\345\256\271\346\230\223\345\244\261\345\216\273\350\207\252\345\267\261.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\203\263\350\242\253\346\211\200\346\234\211\344\272\272\347\220\206\350\247\243\357\274\214\350\266\212\345\256\271\346\230\223\345\244\261\345\216\273\350\207\252\345\267\261.md"
new file mode 100644
index 00000000..c337e121
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\350\266\212\346\203\263\350\242\253\346\211\200\346\234\211\344\272\272\347\220\206\350\247\243\357\274\214\350\266\212\345\256\271\346\230\223\345\244\261\345\216\273\350\207\252\345\267\261.md"
@@ -0,0 +1,75 @@
+# 你越想被所有人理解，越容易失去自己
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“你越想被所有人理解”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、代价为什么总在后期集中爆发
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、别停在共鸣，直接落成流程
+
+　　先把边界写清楚，再谈关系质量。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把注意力压到一周可验证；
+
+　　第二，把信息流放进固定复盘框架；
+
+　　第三，每月重算一次策略。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　越容易失去自己最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、长期主义不是口号，是结算方式
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这条路不花哨，但它靠谱。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 五、给这篇文章一个现实结尾
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 22 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\351\234\200\350\246\201\347\232\204\344\270\215\346\230\257\347\254\254\344\272\214\345\244\247\350\204\221\357\274\214\350\200\214\346\230\257\347\254\254\344\270\200\350\241\214\345\212\250.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\351\234\200\350\246\201\347\232\204\344\270\215\346\230\257\347\254\254\344\272\214\345\244\247\350\204\221\357\274\214\350\200\214\346\230\257\347\254\254\344\270\200\350\241\214\345\212\250.md"
new file mode 100644
index 00000000..4d6fec8b
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\275\240\351\234\200\350\246\201\347\232\204\344\270\215\346\230\257\347\254\254\344\272\214\345\244\247\350\204\221\357\274\214\350\200\214\346\230\257\347\254\254\344\270\200\350\241\214\345\212\250.md"
@@ -0,0 +1,75 @@
+# 你需要的不是第二大脑，而是第一行动
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　关于“你需要的不是第二大脑，而是第一行动”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：关键不在第二大脑，而在第一行动。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、第一步就错位，后面全是补丁
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、把观点变动作：给你可执行的改法
+
+　　先把边界写清楚，再谈关系质量。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把主目标先降频再评估；
+
+　　第二，把关键任务放进固定复盘框架；
+
+　　第三，用小迭代替代大跃进。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、把这层做对，很多问题会自动降级
+
+　　越想稳，越要学会阶段性止损。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这条路不花哨，但它靠谱。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、回到结论：这件事值得你马上重算
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 19 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\277\241\346\201\257\350\277\207\350\275\275\347\232\204\346\234\254\350\264\250\346\230\257\345\206\263\347\255\226\346\201\220\346\203\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\277\241\346\201\257\350\277\207\350\275\275\347\232\204\346\234\254\350\264\250\346\230\257\345\206\263\347\255\226\346\201\220\346\203\247.md"
new file mode 100644
index 00000000..f4350180
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\344\277\241\346\201\257\350\277\207\350\275\275\347\232\204\346\234\254\350\264\250\346\230\257\345\206\263\347\255\226\346\201\220\346\203\247.md"
@@ -0,0 +1,75 @@
+# 信息过载的本质是决策恐惧
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：在“信”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、先谈模型，不急着谈技巧
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、别停在共鸣，直接落成流程
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把项目范围默认延迟非关键项；
+
+　　第二，把任务清单绑定到明确截止日；
+
+　　第三，用真实成本替代理想叙事。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、这一步不酷，但最值钱
+
+　　可恢复性比单次高光更关键。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　把这件事想透，你会少走很多弯路。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　这件事最值钱的地方，就是把模糊变清晰。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 4 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\201\232\345\217\257\351\224\231\347\232\204\345\260\217\345\206\263\347\255\226\357\274\214\345\206\215\345\201\232\344\270\215\345\217\257\351\200\206\347\232\204\345\244\247\345\206\263\347\255\226.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\201\232\345\217\257\351\224\231\347\232\204\345\260\217\345\206\263\347\255\226\357\274\214\345\206\215\345\201\232\344\270\215\345\217\257\351\200\206\347\232\204\345\244\247\345\206\263\347\255\226.md"
new file mode 100644
index 00000000..8b9d68f9
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\201\232\345\217\257\351\224\231\347\232\204\345\260\217\345\206\263\347\255\226\357\274\214\345\206\215\345\201\232\344\270\215\345\217\257\351\200\206\347\232\204\345\244\247\345\206\263\347\255\226.md"
@@ -0,0 +1,75 @@
+# 先做可错的小决策，再做不可逆的大决策
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：这道题不是态度题，是顺序题。顺序错了，再努力也会折损。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、代价为什么总在后期集中爆发
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　再做不可逆的大决策最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+## 三、别停在共鸣，直接落成流程
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把沟通窗口控制到固定时段；
+
+　　第二，把任务清单写成明文规则；
+
+　　第三，用证据替代自责。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、你最容易忽略的边界条件
+
+　　可恢复性比单次高光更关键。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在再做不可逆的大决策下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　这不是消极，而是对长期负责。
+## 五、如果只记住一句话，我希望是这个
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　当你愿意在再做不可逆的大决策多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 17 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\210\253\346\217\220\351\253\230\346\211\247\350\241\214\345\212\233\357\274\214\345\205\210\345\207\217\345\260\221\344\272\272\347\224\237\345\231\252\345\243\260.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\210\253\346\217\220\351\253\230\346\211\247\350\241\214\345\212\233\357\274\214\345\205\210\345\207\217\345\260\221\344\272\272\347\224\237\345\231\252\345\243\260.md"
new file mode 100644
index 00000000..8ed8609c
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\210\253\346\217\220\351\253\230\346\211\247\350\241\214\345\212\233\357\274\214\345\205\210\345\207\217\345\260\221\344\272\272\347\224\237\345\231\252\345\243\260.md"
@@ -0,0 +1,75 @@
+# 先别提高执行力，先减少人生噪声
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：多数人输在“先减少人生噪声”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、第一步就错位，后面全是补丁
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　先减少人生噪声最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、如果要改，从这里开始最省成本
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把消费冲动先降频再评估；
+
+　　第二，把承诺清单切到单线程推进；
+
+　　第三，用真实成本替代理想叙事。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、长期主义不是口号，是结算方式
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　这件事最值钱的地方，就是把模糊变清晰。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　这不是消极，而是对长期负责。
+## 五、收束：你该真正守住的东西
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 6 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\255\246\344\274\232\347\273\223\346\235\237\357\274\214\345\206\215\350\260\210\345\274\200\345\247\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\255\246\344\274\232\347\273\223\346\235\237\357\274\214\345\206\215\350\260\210\345\274\200\345\247\213.md"
new file mode 100644
index 00000000..377f7c9e
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\210\345\255\246\344\274\232\347\273\223\346\235\237\357\274\214\345\206\215\350\260\210\345\274\200\345\247\213.md"
@@ -0,0 +1,75 @@
+# 先学会结束，再谈开始
+
+　　这不是观点输出，而是一次认知止损。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：这道题不是态度题，是顺序题。顺序错了，再努力也会折损。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、别停在共鸣，直接落成流程
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把沟通窗口减少到最小必要集；
+
+　　第二，把执行窗口只保留前三优先项；
+
+　　第三，用规则替代临场猜测。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、把这层做对，很多问题会自动降级
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　先学会结束最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、最后回到最朴素的算术
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 25 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\215\350\264\271\345\273\272\350\256\256\344\270\272\344\273\200\344\271\210\346\234\200\350\264\265.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\215\350\264\271\345\273\272\350\256\256\344\270\272\344\273\200\344\271\210\346\234\200\350\264\265.md"
new file mode 100644
index 00000000..9ac76b80
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\215\350\264\271\345\273\272\350\256\256\344\270\272\344\273\200\344\271\210\346\234\200\350\264\265.md"
@@ -0,0 +1,75 @@
+# 免费建议为什么最贵
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：“免”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、从机制看，这里到底错在哪
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　免最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+## 三、把抽象建议拆成现实动作
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把日程密度加入止损条件；
+
+　　第二，把沟通窗口只保留前三优先项；
+
+　　第三，用可持续替代高压。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　真正省力的方法，通常都先从校准开始。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、你最容易忽略的边界条件
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　这不是消极，而是对长期负责。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　你不需要更狠，你需要更准。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 3 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\205\254\345\271\263\344\270\215\346\230\257\345\271\263\345\235\207\344\273\230\345\207\272\357\274\214\350\200\214\346\230\257\345\257\271\347\255\211\346\211\277\350\257\272.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\205\254\345\271\263\344\270\215\346\230\257\345\271\263\345\235\207\344\273\230\345\207\272\357\274\214\350\200\214\346\230\257\345\257\271\347\255\211\346\211\277\350\257\272.md"
new file mode 100644
index 00000000..bdf28ce3
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\205\254\345\271\263\344\270\215\346\230\257\345\271\263\345\235\207\344\273\230\345\207\272\357\274\214\350\200\214\346\230\257\345\257\271\347\255\211\346\211\277\350\257\272.md"
@@ -0,0 +1,75 @@
+# 关系中的公平不是平均付出，而是对等承诺
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：关键不在平均付出，而在对等承诺。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、代价为什么总在后期集中爆发
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　很多人会在关系中的公平不是平均付出下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、从今天就能开始的三步动作
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把注意力加上结果验收标准；
+
+　　第二，把复盘节点放进固定复盘框架；
+
+　　第三，用反馈闭环替代盲做。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、这一步不酷，但最值钱
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这一步做实，后面的动作才会开始有复利。
+## 五、如果只记住一句话，我希望是这个
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 2 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\256\211\345\205\250\346\204\237\346\235\245\350\207\252\345\217\257\351\242\204\346\265\213\357\274\214\350\200\214\351\235\236\351\253\230\345\274\272\345\272\246\351\231\252\344\274\264.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\256\211\345\205\250\346\204\237\346\235\245\350\207\252\345\217\257\351\242\204\346\265\213\357\274\214\350\200\214\351\235\236\351\253\230\345\274\272\345\272\246\351\231\252\344\274\264.md"
new file mode 100644
index 00000000..10140fe0
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\344\270\255\347\232\204\345\256\211\345\205\250\346\204\237\346\235\245\350\207\252\345\217\257\351\242\204\346\265\213\357\274\214\350\200\214\351\235\236\351\253\230\345\274\272\345\272\246\351\231\252\344\274\264.md"
@@ -0,0 +1,75 @@
+# 关系中的安全感来自可预测，而非高强度陪伴
+
+　　这不是观点输出，而是一次认知止损。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：“关系中的安全感来自可预测”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在而非高强度陪伴下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以而非高强度陪伴的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先把边界写清楚，再谈关系质量。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把日程密度改为低成本试错；
+
+　　第二，把关键任务默认延迟非关键项；
+
+　　第三，用边界替代讨好。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、别把旧赢法当成永久通行证
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+## 五、最后一句狠话：先做对，再做快
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　当你愿意在而非高强度陪伴多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 15 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\345\264\251\347\233\230\345\270\270\345\270\270\344\270\215\346\230\257\344\273\267\345\200\274\350\247\202\345\206\262\347\252\201\357\274\214\350\200\214\346\230\257\345\215\217\350\256\256\347\274\272\345\270\255.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\345\264\251\347\233\230\345\270\270\345\270\270\344\270\215\346\230\257\344\273\267\345\200\274\350\247\202\345\206\262\347\252\201\357\274\214\350\200\214\346\230\257\345\215\217\350\256\256\347\274\272\345\270\255.md"
new file mode 100644
index 00000000..7227aa46
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\345\264\251\347\233\230\345\270\270\345\270\270\344\270\215\346\230\257\344\273\267\345\200\274\350\247\202\345\206\262\347\252\201\357\274\214\350\200\214\346\230\257\345\215\217\350\256\256\347\274\272\345\270\255.md"
@@ -0,0 +1,75 @@
+# 关系崩盘常常不是价值观冲突，而是协议缺席
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：关键不在价值观冲突，而在协议缺席。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把作息边界先做最难的一步；
+
+　　第二，把输出节奏拆到当天可完成；
+
+　　第三，用系统替代鸡血。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　关系崩盘常常不是价值观冲突最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、边界、止损与可重启能力
+
+　　这一步看起来不酷，但最值钱。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、收束：你该真正守住的东西
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　先止损，再进攻，通常更稳。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 21 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\351\207\214\347\232\204\344\275\223\351\235\242\345\270\270\345\270\270\346\235\245\350\207\252\346\217\220\345\211\215\346\212\245\344\273\267.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\351\207\214\347\232\204\344\275\223\351\235\242\345\270\270\345\270\270\346\235\245\350\207\252\346\217\220\345\211\215\346\212\245\344\273\267.md"
new file mode 100644
index 00000000..02fefaac
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\205\263\347\263\273\351\207\214\347\232\204\344\275\223\351\235\242\345\270\270\345\270\270\346\235\245\350\207\252\346\217\220\345\211\215\346\212\245\344\273\267.md"
@@ -0,0 +1,75 @@
+# 关系里的体面常常来自提前报价
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：“关”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、先谈模型，不急着谈技巧
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　很多人会在关下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、先降摩擦，再提强度
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把项目范围写成明文规则；
+
+　　第二，把沟通窗口按优先级重排；
+
+　　第三，遇到越界立即处理。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　你真正要拿回来的，是选择权。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、最后回到最朴素的算术
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　别让短期体感绑架长期决策。
+
+　　这条路不花哨，但它靠谱。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 6 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\233\351\200\240\345\212\233\344\270\215\346\230\257\347\201\265\346\204\237\351\227\256\351\242\230\357\274\214\346\230\257\347\251\272\347\231\275\346\227\266\351\227\264\351\227\256\351\242\230.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\233\351\200\240\345\212\233\344\270\215\346\230\257\347\201\265\346\204\237\351\227\256\351\242\230\357\274\214\346\230\257\347\251\272\347\231\275\346\227\266\351\227\264\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..0bf6448c
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\233\351\200\240\345\212\233\344\270\215\346\230\257\347\201\265\346\204\237\351\227\256\351\242\230\357\274\214\346\230\257\347\251\272\347\231\275\346\227\266\351\227\264\351\227\256\351\242\230.md"
@@ -0,0 +1,75 @@
+# 创造力不是灵感问题，是空白时间问题
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：多数人输在“是空白时间问题”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、先建立闭环，再谈效率神话
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把作息边界切到单线程推进；
+
+　　第二，把财务缓冲设置上限避免过载；
+
+　　第三，每月重算一次策略。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　这条路不花哨，但它靠谱。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　可迁移能力比短期头衔更保值。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 14 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\244\346\226\255\344\270\200\344\270\252\346\234\272\344\274\232\347\234\213\346\225\205\344\272\213\344\270\215\345\246\202\347\234\213\347\216\260\351\207\221\346\265\201.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\244\346\226\255\344\270\200\344\270\252\346\234\272\344\274\232\347\234\213\346\225\205\344\272\213\344\270\215\345\246\202\347\234\213\347\216\260\351\207\221\346\265\201.md"
new file mode 100644
index 00000000..80e3d376
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\244\346\226\255\344\270\200\344\270\252\346\234\272\344\274\232\347\234\213\346\225\205\344\272\213\344\270\215\345\246\202\347\234\213\347\216\260\351\207\221\346\265\201.md"
@@ -0,0 +1,75 @@
+# 判断一个机会看故事不如看现金流
+
+　　这不是观点输出，而是一次认知止损。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：如果你把“判”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　很多人会在判下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、先建立闭环，再谈效率神话
+
+　　先把边界写清楚，再谈关系质量。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把任务清单减少到最小必要集；
+
+　　第二，把学习路径减少到最小必要集；
+
+　　第三，遇到越界立即处理。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先止损，再进攻，通常更稳。
+## 四、稳定不是不变，而是持续适配
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　这不是消极，而是对长期负责。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 23 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\253\346\212\212\346\210\220\351\225\277\347\220\206\350\247\243\346\210\220\344\270\215\346\226\255\345\212\240\346\263\225\357\274\214\346\234\211\346\227\266\345\207\217\346\263\225\346\211\215\346\230\257\345\215\207\347\272\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\253\346\212\212\346\210\220\351\225\277\347\220\206\350\247\243\346\210\220\344\270\215\346\226\255\345\212\240\346\263\225\357\274\214\346\234\211\346\227\266\345\207\217\346\263\225\346\211\215\346\230\257\345\215\207\347\272\247.md"
new file mode 100644
index 00000000..1f487bef
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\210\253\346\212\212\346\210\220\351\225\277\347\220\206\350\247\243\346\210\220\344\270\215\346\226\255\345\212\240\346\263\225\357\274\214\346\234\211\346\227\266\345\207\217\346\263\225\346\211\215\346\230\257\345\215\207\347\272\247.md"
@@ -0,0 +1,75 @@
+# 别把成长理解成不断加法，有时减法才是升级
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：“有时减法才是升级”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　有时减法才是升级最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、如果要改，从这里开始最省成本
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把输出节奏加上结果验收标准；
+
+　　第二，把复盘节点限定在可恢复负荷；
+
+　　第三，用清单替代情绪。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　只要不再重复同类错误，成长就会发生。
+## 四、把这层做对，很多问题会自动降级
+
+　　你不必最锋利，但一定要可重启。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、最后回到最朴素的算术
+
+　　把这件事想透，你会少走很多弯路。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 21 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\345\246\202\346\236\234\346\262\241\346\234\211\346\226\271\345\220\221\357\274\214\345\217\252\344\274\232\346\217\220\351\253\230\350\277\267\350\267\257\351\200\237\345\272\246.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\345\246\202\346\236\234\346\262\241\346\234\211\346\226\271\345\220\221\357\274\214\345\217\252\344\274\232\346\217\220\351\253\230\350\277\267\350\267\257\351\200\237\345\272\246.md"
new file mode 100644
index 00000000..0a1a4408
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\345\246\202\346\236\234\346\262\241\346\234\211\346\226\271\345\220\221\357\274\214\345\217\252\344\274\232\346\217\220\351\253\230\350\277\267\350\267\257\351\200\237\345\272\246.md"
@@ -0,0 +1,75 @@
+# 勤奋如果没有方向，只会提高迷路速度
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：如果你把“只会提高迷路速度”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　很多人会在只会提高迷路速度下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　只会提高迷路速度最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、如果要改，从这里开始最省成本
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把承诺清单转成可追踪指标；
+
+　　第二，把作息边界切到单线程推进；
+
+　　第三，用慢变量替代热点追逐。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　这一步做实，后面的动作才会开始有复利。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 8 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\345\276\227\347\232\204\347\227\205\345\217\253\347\273\251\346\225\210\344\272\272\346\240\274.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\345\276\227\347\232\204\347\227\205\345\217\253\347\273\251\346\225\210\344\272\272\346\240\274.md"
new file mode 100644
index 00000000..41173636
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\213\244\345\245\213\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\345\276\227\347\232\204\347\227\205\345\217\253\347\273\251\346\225\210\344\272\272\346\240\274.md"
@@ -0,0 +1,75 @@
+# 勤奋的人最容易得的病叫绩效人格
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　关于“勤奋的人最容易得的病叫绩效人格”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、第一步就错位，后面全是补丁
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、长期账本里，什么才是大头
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、别停在共鸣，直接落成流程
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把信息流设置上限避免过载；
+
+　　第二，把沟通窗口设定触发即处理机制；
+
+　　第三，用结果替代表演。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　勤最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、真正的分水岭：纠偏速度
+
+　　你不必最锋利，但一定要可重启。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、如果只记住一句话，我希望是这个
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　别让短期体感绑架长期决策。
+
+　　先止损，再进攻，通常更稳。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 12 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\345\244\232\345\220\203\350\213\246\357\274\214\346\230\257\345\244\232\347\225\231\345\220\216\346\211\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\345\244\232\345\220\203\350\213\246\357\274\214\346\230\257\345\244\232\347\225\231\345\220\216\346\211\213.md"
new file mode 100644
index 00000000..92319790
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\345\244\232\345\220\203\350\213\246\357\274\214\346\230\257\345\244\232\347\225\231\345\220\216\346\211\213.md"
@@ -0,0 +1,75 @@
+# 反脆弱不是多吃苦，是多留后手
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：多数人输在“是多留后手”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、代价为什么总在后期集中爆发
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、这件事落地，核心不在狠而在稳
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把承诺清单压到一周可验证；
+
+　　第二，把关键任务设置上限避免过载；
+
+　　第三，用节律替代冲刺。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、给这篇文章一个现实结尾
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先止损，再进攻，通常更稳。
+
+　　所以反脆弱不是多吃苦的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 8 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\347\241\254\346\211\233\357\274\214\346\230\257\345\277\253\351\200\237\346\201\242\345\244\215\345\222\214\351\207\215\346\236\204.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\347\241\254\346\211\233\357\274\214\346\230\257\345\277\253\351\200\237\346\201\242\345\244\215\345\222\214\351\207\215\346\236\204.md"
new file mode 100644
index 00000000..02f9c938
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\217\215\350\204\206\345\274\261\344\270\215\346\230\257\347\241\254\346\211\233\357\274\214\346\230\257\345\277\253\351\200\237\346\201\242\345\244\215\345\222\214\351\207\215\346\236\204.md"
@@ -0,0 +1,75 @@
+# 反脆弱不是硬扛，是快速恢复和重构
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“反脆弱不是硬扛”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、这件事最常见的误读是什么
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、如果要改，从这里开始最省成本
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把任务清单加入止损条件；
+
+　　第二，把项目范围控制到固定时段；
+
+　　第三，用规则替代临场猜测。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　这条路不花哨，但它靠谱。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、给这篇文章一个现实结尾
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　是快速恢复和重构最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 21 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\210\347\276\244\347\204\246\350\231\221\346\234\254\350\264\250\346\230\257\350\257\204\344\273\267\346\235\203\345\244\226\345\214\205.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\210\347\276\244\347\204\246\350\231\221\346\234\254\350\264\250\346\230\257\350\257\204\344\273\267\346\235\203\345\244\226\345\214\205.md"
new file mode 100644
index 00000000..f20ef5fd
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\210\347\276\244\347\204\246\350\231\221\346\234\254\350\264\250\346\230\257\350\257\204\344\273\267\346\235\203\345\244\226\345\214\205.md"
@@ -0,0 +1,75 @@
+# 合群焦虑本质是评价权外包
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“合”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、从机制看，这里到底错在哪
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、代价为什么总在后期集中爆发
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、这件事落地，核心不在狠而在稳
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把承诺清单拆到当天可完成；
+
+　　第二，把信息流写成明文规则；
+
+　　第三，每月重算一次策略。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、边界、止损与可重启能力
+
+　　这一步看起来不酷，但最值钱。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 18 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\254\345\273\272\350\256\256\347\232\204\346\240\270\345\277\203\344\270\215\346\230\257\345\220\254\350\260\201\345\216\211\345\256\263\357\274\214\350\200\214\346\230\257\350\260\201\346\211\277\346\213\205\345\220\216\346\236\234.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\254\345\273\272\350\256\256\347\232\204\346\240\270\345\277\203\344\270\215\346\230\257\345\220\254\350\260\201\345\216\211\345\256\263\357\274\214\350\200\214\346\230\257\350\260\201\346\211\277\346\213\205\345\220\216\346\236\234.md"
new file mode 100644
index 00000000..b73eacb3
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\220\254\345\273\272\350\256\256\347\232\204\346\240\270\345\277\203\344\270\215\346\230\257\345\220\254\350\260\201\345\216\211\345\256\263\357\274\214\350\200\214\346\230\257\350\260\201\346\211\277\346\213\205\345\220\216\346\236\234.md"
@@ -0,0 +1,75 @@
+# 听建议的核心不是听谁厉害，而是谁承担后果
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：关键不在听谁厉害，而在谁承担后果。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　很多人会在听建议的核心不是听谁厉害下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、先降摩擦，再提强度
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把关键任务限定在可恢复负荷；
+
+　　第二，把输入渠道按优先级重排；
+
+　　第三，用低摩擦替代硬扛。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　听建议的核心不是听谁厉害最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　先止损，再进攻，通常更稳。
+## 四、长期主义不是口号，是结算方式
+
+　　你不必最锋利，但一定要可重启。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　这不是消极，而是对长期负责。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　把这件事想透，你会少走很多弯路。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 25 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\226\204\346\204\217\345\246\202\346\236\234\344\270\215\350\203\275\346\213\222\347\273\235\357\274\214\345\260\261\344\274\232\345\217\230\346\210\220\347\272\265\345\256\271.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\226\204\346\204\217\345\246\202\346\236\234\344\270\215\350\203\275\346\213\222\347\273\235\357\274\214\345\260\261\344\274\232\345\217\230\346\210\220\347\272\265\345\256\271.md"
new file mode 100644
index 00000000..e41a30ce
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\226\204\346\204\217\345\246\202\346\236\234\344\270\215\350\203\275\346\213\222\347\273\235\357\274\214\345\260\261\344\274\232\345\217\230\346\210\220\347\272\265\345\256\271.md"
@@ -0,0 +1,75 @@
+# 善意如果不能拒绝，就会变成纵容
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：多数人输在“就会变成纵容”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　很多人会在就会变成纵容下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、先建立闭环，再谈效率神话
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把关键任务只保留前三优先项；
+
+　　第二，把协作节奏先降频再评估；
+
+　　第三，用低摩擦替代硬扛。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　只要不再重复同类错误，成长就会发生。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　越想稳，越要学会阶段性止损。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、给这篇文章一个现实结尾
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　就会变成纵容最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 17 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\226\347\225\214\350\256\244\345\217\257\344\270\212\347\230\276\344\274\232\350\256\251\344\275\240\344\270\247\345\244\261\345\223\201\345\221\263\344\270\273\346\235\203.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\226\347\225\214\350\256\244\345\217\257\344\270\212\347\230\276\344\274\232\350\256\251\344\275\240\344\270\247\345\244\261\345\223\201\345\221\263\344\270\273\346\235\203.md"
new file mode 100644
index 00000000..751e581f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\226\347\225\214\350\256\244\345\217\257\344\270\212\347\230\276\344\274\232\350\256\251\344\275\240\344\270\247\345\244\261\345\223\201\345\221\263\344\270\273\346\235\203.md"
@@ -0,0 +1,75 @@
+# 外界认可上瘾会让你丧失品味主权
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：在“外”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　外最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+## 三、别停在共鸣，直接落成流程
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把主目标加入止损条件；
+
+　　第二，把信息流改为低成本试错；
+
+　　第三，用长期账替代短期爽。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 四、稳定不是不变，而是持续适配
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+## 五、最后回到最朴素的算术
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 30 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\232\347\272\277\347\250\213\344\272\272\347\224\237\347\234\213\350\265\267\346\235\245\345\277\231\357\274\214\345\256\236\345\210\231\346\230\223\347\240\264\344\272\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\232\347\272\277\347\250\213\344\272\272\347\224\237\347\234\213\350\265\267\346\235\245\345\277\231\357\274\214\345\256\236\345\210\231\346\230\223\347\240\264\344\272\247.md"
new file mode 100644
index 00000000..534bb50c
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\244\232\347\272\277\347\250\213\344\272\272\347\224\237\347\234\213\350\265\267\346\235\245\345\277\231\357\274\214\345\256\236\345\210\231\346\230\223\347\240\264\344\272\247.md"
@@ -0,0 +1,75 @@
+# 多线程人生看起来忙，实则易破产
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：在“实则易破产”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　实则易破产最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先守住节律，再追求峰值表现。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把情绪触发器只保留前三优先项；
+
+　　第二，把人际暴露按优先级重排；
+
+　　第三，用证据替代自责。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、真正的分水岭：纠偏速度
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　很多人会在实则易破产下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、回到结论：这件事值得你马上重算
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　先止损，再进攻，通常更稳。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 26 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\255\246\344\274\232\346\217\220\350\246\201\346\261\202\346\257\224\345\255\246\344\274\232\345\277\215\350\200\220\346\233\264\351\207\215\350\246\201.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\255\246\344\274\232\346\217\220\350\246\201\346\261\202\346\257\224\345\255\246\344\274\232\345\277\215\350\200\220\346\233\264\351\207\215\350\246\201.md"
new file mode 100644
index 00000000..fdfc4297
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\255\246\344\274\232\346\217\220\350\246\201\346\261\202\346\257\224\345\255\246\344\274\232\345\277\215\350\200\220\346\233\264\351\207\215\350\246\201.md"
@@ -0,0 +1,75 @@
+# 学会提要求比学会忍耐更重要
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“学”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、先降摩擦，再提强度
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把信息流放进固定复盘框架；
+
+　　第二，把复盘节点改为低成本试错；
+
+　　第三，用低摩擦替代硬扛。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　你不需要更狠，你需要更准。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 29 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\257\271\346\212\227\347\204\246\350\231\221\346\234\200\346\234\211\346\225\210\347\232\204\346\226\271\345\274\217\344\270\215\346\230\257\346\224\276\346\235\276\357\274\214\350\200\214\346\230\257\345\256\232\344\273\267.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\257\271\346\212\227\347\204\246\350\231\221\346\234\200\346\234\211\346\225\210\347\232\204\346\226\271\345\274\217\344\270\215\346\230\257\346\224\276\346\235\276\357\274\214\350\200\214\346\230\257\345\256\232\344\273\267.md"
new file mode 100644
index 00000000..293d94a8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\257\271\346\212\227\347\204\246\350\231\221\346\234\200\346\234\211\346\225\210\347\232\204\346\226\271\345\274\217\344\270\215\346\230\257\346\224\276\346\235\276\357\274\214\350\200\214\346\230\257\345\256\232\344\273\267.md"
@@ -0,0 +1,75 @@
+# 对抗焦虑最有效的方式不是放松，而是定价
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：关键不在放松，而在定价。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、表层很合理，底层很昂贵
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　当你愿意在而是定价多花一点耐心，后面的很多冲突会自动降级。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　而是定价最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以而是定价的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把人际暴露先做最难的一步；
+
+　　第二，把输入渠道改为低成本试错；
+
+　　第三，用长期账替代短期爽。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　可迁移能力比短期头衔更保值。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+## 五、收束：你该真正守住的东西
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　先做对，再做快，这几乎永远不会错。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 11 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\267\245\344\275\234\347\250\263\345\256\232\346\204\237\346\235\245\350\207\252\345\217\257\350\277\201\347\247\273\350\265\204\344\272\247\357\274\214\344\270\215\346\230\257\345\267\245\347\211\214.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\267\245\344\275\234\347\250\263\345\256\232\346\204\237\346\235\245\350\207\252\345\217\257\350\277\201\347\247\273\350\265\204\344\272\247\357\274\214\344\270\215\346\230\257\345\267\245\347\211\214.md"
new file mode 100644
index 00000000..783adba5
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\267\245\344\275\234\347\250\263\345\256\232\346\204\237\346\235\245\350\207\252\345\217\257\350\277\201\347\247\273\350\265\204\344\272\247\357\274\214\344\270\215\346\230\257\345\267\245\347\211\214.md"
@@ -0,0 +1,75 @@
+# 工作稳定感来自可迁移资产，不是工牌
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：“工作稳定感来自可迁移资产”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、这件事最常见的误读是什么
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、把抽象建议拆成现实动作
+
+　　先守住节律，再追求峰值表现。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把关键任务控制到固定时段；
+
+　　第二，把人际暴露改为低成本试错；
+
+　　第三，用节律替代冲刺。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、边界、止损与可重启能力
+
+　　你不必最锋利，但一定要可重启。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、最后回到最朴素的算术
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　你真正要拿回来的，是选择权。
+
+　　这条路不花哨，但它靠谱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 17 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\273\266\350\277\237\346\273\241\350\266\263\350\242\253\346\273\245\347\224\250\346\210\220\344\272\206\345\216\213\346\212\221\345\267\245\345\205\267.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\273\266\350\277\237\346\273\241\350\266\263\350\242\253\346\273\245\347\224\250\346\210\220\344\272\206\345\216\213\346\212\221\345\267\245\345\205\267.md"
new file mode 100644
index 00000000..b5a6eb3f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\273\266\350\277\237\346\273\241\350\266\263\350\242\253\346\273\245\347\224\250\346\210\220\344\272\206\345\216\213\346\212\221\345\267\245\345\205\267.md"
@@ -0,0 +1,75 @@
+# 延迟满足被滥用成了压抑工具
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：如果你把“延”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、从今天就能开始的三步动作
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把关键任务压到一周可验证；
+
+　　第二，把沟通窗口设置上限避免过载；
+
+　　第三，用系统替代鸡血。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+## 四、别把旧赢法当成永久通行证
+
+　　越想稳，越要学会阶段性止损。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　这条路不花哨，但它靠谱。
+
+　　这不是消极，而是对长期负责。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 10 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\274\272\350\200\205\346\200\235\347\273\264\346\234\200\345\270\270\350\247\201\350\257\257\347\224\250\346\230\257\345\277\275\347\225\245\347\263\273\347\273\237\346\210\220\346\234\254.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\274\272\350\200\205\346\200\235\347\273\264\346\234\200\345\270\270\350\247\201\350\257\257\347\224\250\346\230\257\345\277\275\347\225\245\347\263\273\347\273\237\346\210\220\346\234\254.md"
new file mode 100644
index 00000000..d23091f7
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\274\272\350\200\205\346\200\235\347\273\264\346\234\200\345\270\270\350\247\201\350\257\257\347\224\250\346\230\257\345\277\275\347\225\245\347\263\273\347\273\237\346\210\220\346\234\254.md"
@@ -0,0 +1,75 @@
+# 强者思维最常见误用是忽略系统成本
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：如果你把“强”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、长期账本里，什么才是大头
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、先建立闭环，再谈效率神话
+
+　　先守住节律，再追求峰值表现。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把执行窗口压到一周可验证；
+
+　　第二，把输入渠道默认延迟非关键项；
+
+　　第三，每周固定一次复盘。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　这条路不花哨，但它靠谱。
+## 四、长期主义不是口号，是结算方式
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　强最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 18 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\275\223\344\275\240\346\200\273\345\234\250\350\257\201\346\230\216\350\207\252\345\267\261\346\227\266\357\274\214\344\275\240\345\260\261\345\234\250\345\244\261\345\216\273\350\207\252\345\267\261.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\275\223\344\275\240\346\200\273\345\234\250\350\257\201\346\230\216\350\207\252\345\267\261\346\227\266\357\274\214\344\275\240\345\260\261\345\234\250\345\244\261\345\216\273\350\207\252\345\267\261.md"
new file mode 100644
index 00000000..f478b3fd
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\275\223\344\275\240\346\200\273\345\234\250\350\257\201\346\230\216\350\207\252\345\267\261\346\227\266\357\274\214\344\275\240\345\260\261\345\234\250\345\244\261\345\216\273\350\207\252\345\267\261.md"
@@ -0,0 +1,75 @@
+# 当你总在证明自己时，你就在失去自己
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：“当你总在证明自己时”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、从机制看，这里到底错在哪
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　当你总在证明自己时最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、代价为什么总在后期集中爆发
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、把抽象建议拆成现实动作
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把项目范围按优先级重排；
+
+　　第二，把财务缓冲加入止损条件；
+
+　　第三，用小迭代替代大跃进。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、边界、止损与可重启能力
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、给这篇文章一个现实结尾
+
+　　把这件事想透，你会少走很多弯路。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　别让短期体感绑架长期决策。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 29 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\231\347\242\214\346\230\257\346\234\200\345\256\271\346\230\223\344\270\212\347\230\276\347\232\204\351\200\203\351\201\277\346\226\271\345\274\217.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\231\347\242\214\346\230\257\346\234\200\345\256\271\346\230\223\344\270\212\347\230\276\347\232\204\351\200\203\351\201\277\346\226\271\345\274\217.md"
new file mode 100644
index 00000000..43fe0a16
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\231\347\242\214\346\230\257\346\234\200\345\256\271\346\230\223\344\270\212\347\230\276\347\232\204\351\200\203\351\201\277\346\226\271\345\274\217.md"
@@ -0,0 +1,75 @@
+# 忙碌是最容易上瘾的逃避方式
+
+　　这不是观点输出，而是一次认知止损。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、这件事最常见的误读是什么
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、把观点变动作：给你可执行的改法
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把任务清单拆到当天可完成；
+
+　　第二，把执行窗口设置上限避免过载；
+
+　　第三，每月重算一次策略。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　忙最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、真正的分水岭：纠偏速度
+
+　　这一步看起来不酷，但最值钱。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　当你开始按证据推进，焦虑会自然下降。
+## 五、最后一句狠话：先做对，再做快
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 7 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\253\351\200\237\345\217\215\351\246\210\344\274\232\346\212\212\344\272\272\350\256\255\347\273\203\346\210\220\347\237\255\347\272\277\344\272\272\346\240\274.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\253\351\200\237\345\217\215\351\246\210\344\274\232\346\212\212\344\272\272\350\256\255\347\273\203\346\210\220\347\237\255\347\272\277\344\272\272\346\240\274.md"
new file mode 100644
index 00000000..2069a585
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\345\277\253\351\200\237\345\217\215\351\246\210\344\274\232\346\212\212\344\272\272\350\256\255\347\273\203\346\210\220\347\237\255\347\272\277\344\272\272\346\240\274.md"
@@ -0,0 +1,75 @@
+# 快速反馈会把人训练成短线人格
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：在“快”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、这件事最常见的误读是什么
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多人会在快下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　所以快的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、长期账本里，什么才是大头
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、先建立闭环，再谈效率神话
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把消费冲动切到单线程推进；
+
+　　第二，把主目标转成可追踪指标；
+
+　　第三，每月重算一次策略。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　你不必最锋利，但一定要可重启。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　把问题协议化，很多摩擦会提前消失。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　快最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 28 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\344\273\267\345\200\274\344\270\215\346\230\257\345\223\204\344\272\272\357\274\214\346\230\257\351\231\215\344\275\216\345\205\263\347\263\273\344\272\244\346\230\223\346\210\220\346\234\254.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\344\273\267\345\200\274\344\270\215\346\230\257\345\223\204\344\272\272\357\274\214\346\230\257\351\231\215\344\275\216\345\205\263\347\263\273\344\272\244\346\230\223\346\210\220\346\234\254.md"
new file mode 100644
index 00000000..adafbf59
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\344\273\267\345\200\274\344\270\215\346\230\257\345\223\204\344\272\272\357\274\214\346\230\257\351\231\215\344\275\216\345\205\263\347\263\273\344\272\244\346\230\223\346\210\220\346\234\254.md"
@@ -0,0 +1,75 @@
+# 情绪价值不是哄人，是降低关系交易成本
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：在“情绪价值不是哄人”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、表层很合理，底层很昂贵
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　当你愿意在情绪价值不是哄人多花一点耐心，后面的很多冲突会自动降级。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　所以情绪价值不是哄人的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、从今天就能开始的三步动作
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把情绪触发器按优先级重排；
+
+　　第二，把财务缓冲改为低成本试错；
+
+　　第三，用规则替代临场猜测。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先止损，再进攻，通常更稳。
+## 四、把这层做对，很多问题会自动降级
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、给这篇文章一个现实结尾
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 26 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\345\206\205\350\200\227\345\270\270\345\270\270\346\230\257\350\276\271\347\225\214\345\244\226\345\214\205\347\232\204\347\273\223\346\236\234.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\345\206\205\350\200\227\345\270\270\345\270\270\346\230\257\350\276\271\347\225\214\345\244\226\345\214\205\347\232\204\347\273\223\346\236\234.md"
new file mode 100644
index 00000000..23d4398b
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\345\206\205\350\200\227\345\270\270\345\270\270\346\230\257\350\276\271\347\225\214\345\244\226\345\214\205\347\232\204\347\273\223\346\236\234.md"
@@ -0,0 +1,75 @@
+# 情绪内耗常常是边界外包的结果
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“情”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　当你愿意在情多花一点耐心，后面的很多冲突会自动降级。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、如果要改，从这里开始最省成本
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把任务清单先降频再评估；
+
+　　第二，把消费冲动加入止损条件；
+
+　　第三，用边界替代讨好。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　很多人会在情下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　可恢复性比单次高光更关键。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、最后回到最朴素的算术
+
+　　你不需要更狠，你需要更准。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　先止损，再进攻，通常更稳。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 6 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\210\206\345\217\221\351\200\232\345\270\270\346\230\257\351\225\277\346\234\237\345\260\217\345\244\261\345\256\210\347\232\204\346\200\273\345\222\214.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\210\206\345\217\221\351\200\232\345\270\270\346\230\257\351\225\277\346\234\237\345\260\217\345\244\261\345\256\210\347\232\204\346\200\273\345\222\214.md"
new file mode 100644
index 00000000..26eceb16
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\210\206\345\217\221\351\200\232\345\270\270\346\230\257\351\225\277\346\234\237\345\260\217\345\244\261\345\256\210\347\232\204\346\200\273\345\222\214.md"
@@ -0,0 +1,75 @@
+# 情绪爆发通常是长期小失守的总和
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“情”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、把观点变动作：给你可执行的改法
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把关键任务切到单线程推进；
+
+　　第二，把沟通窗口转成可追踪指标；
+
+　　第三，用证据替代自责。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、别把旧赢法当成永久通行证
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　很多人会在情下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 11 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\250\263\345\256\232\344\270\215\346\230\257\346\262\241\350\204\276\346\260\224\357\274\214\350\200\214\346\230\257\346\234\211\350\276\271\347\225\214\350\204\232\346\234\254.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\250\263\345\256\232\344\270\215\346\230\257\346\262\241\350\204\276\346\260\224\357\274\214\350\200\214\346\230\257\346\234\211\350\276\271\347\225\214\350\204\232\346\234\254.md"
new file mode 100644
index 00000000..71a200a1
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\205\347\273\252\347\250\263\345\256\232\344\270\215\346\230\257\346\262\241\350\204\276\346\260\224\357\274\214\350\200\214\346\230\257\346\234\211\350\276\271\347\225\214\350\204\232\346\234\254.md"
@@ -0,0 +1,75 @@
+# 情绪稳定不是没脾气，而是有边界脚本
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：关键不在没脾气，而在有边界脚本。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　所以情绪稳定不是没脾气的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、先降摩擦，再提强度
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把任务清单切到单线程推进；
+
+　　第二，把情绪触发器放进固定复盘框架；
+
+　　第三，用低摩擦替代硬扛。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　很多人会在情绪稳定不是没脾气下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、把这层做对，很多问题会自动降级
+
+　　稳定不是不变，而是持续适配。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这不是消极，而是对长期负责。
+## 五、如果只记住一句话，我希望是这个
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　别让短期体感绑架长期决策。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 4 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\263\346\217\220\345\215\207\350\241\250\350\276\276\345\205\210\345\255\246\344\274\232\345\256\232\344\271\211\351\227\256\351\242\230.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\263\346\217\220\345\215\207\350\241\250\350\276\276\345\205\210\345\255\246\344\274\232\345\256\232\344\271\211\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..49f811a3
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\203\263\346\217\220\345\215\207\350\241\250\350\276\276\345\205\210\345\255\246\344\274\232\345\256\232\344\271\211\351\227\256\351\242\230.md"
@@ -0,0 +1,75 @@
+# 想提升表达先学会定义问题
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“想”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、把观点变动作：给你可执行的改法
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把学习路径先做最难的一步；
+
+　　第二，把执行窗口拆到当天可完成；
+
+　　第三，用慢变量替代热点追逐。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、别把旧赢法当成永久通行证
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、最后回到最朴素的算术
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 29 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\204\244\346\200\222\347\256\241\347\220\206\344\270\215\346\230\257\345\216\213\344\275\217\347\201\253\357\274\214\350\200\214\346\230\257\351\207\215\345\206\231\350\247\246\345\217\221\345\231\250.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\204\244\346\200\222\347\256\241\347\220\206\344\270\215\346\230\257\345\216\213\344\275\217\347\201\253\357\274\214\350\200\214\346\230\257\351\207\215\345\206\231\350\247\246\345\217\221\345\231\250.md"
new file mode 100644
index 00000000..2cc3ef20
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\204\244\346\200\222\347\256\241\347\220\206\344\270\215\346\230\257\345\216\213\344\275\217\347\201\253\357\274\214\350\200\214\346\230\257\351\207\215\345\206\231\350\247\246\345\217\221\345\231\250.md"
@@ -0,0 +1,75 @@
+# 愤怒管理不是压住火，而是重写触发器
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：关键不在压住火，而在重写触发器。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、第一步就错位，后面全是补丁
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、长期账本里，什么才是大头
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　系统健康，比一次高光重要得多。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、把抽象建议拆成现实动作
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把执行窗口默认延迟非关键项；
+
+　　第二，把关键任务写成明文规则；
+
+　　第三，用证据替代自责。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　先止损，再进攻，通常更稳。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　可恢复性比单次高光更关键。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　很多人会在而是重写触发器下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、回到结论：这件事值得你马上重算
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 1 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\205\242\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\347\233\262\345\277\253\346\211\215\346\230\257\351\227\256\351\242\230.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\205\242\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\347\233\262\345\277\253\346\211\215\346\230\257\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..b22f0895
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\205\242\344\270\215\346\230\257\351\227\256\351\242\230\357\274\214\347\233\262\345\277\253\346\211\215\346\230\257\351\227\256\351\242\230.md"
@@ -0,0 +1,75 @@
+# 慢不是问题，盲快才是问题
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：多数人输在“慢不是问题”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、这件事最常见的误读是什么
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　很多人会在慢不是问题下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　当你愿意在慢不是问题多花一点耐心，后面的很多冲突会自动降级。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、从今天就能开始的三步动作
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把输出节奏写成明文规则；
+
+　　第二，把输出节奏先降频再评估；
+
+　　第三，用真实成本替代理想叙事。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、把这层做对，很多问题会自动降级
+
+　　你不必最锋利，但一定要可重启。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　慢不是问题最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　这不是消极，而是对长期负责。
+## 五、给这篇文章一个现实结尾
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 20 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\270\215\345\223\255\357\274\214\346\230\257\350\203\275\350\276\271\345\223\255\350\276\271\345\201\232\345\206\263\347\255\226.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\270\215\345\223\255\357\274\214\346\230\257\350\203\275\350\276\271\345\223\255\350\276\271\345\201\232\345\206\263\347\255\226.md"
new file mode 100644
index 00000000..dfbeebe5
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\270\215\345\223\255\357\274\214\346\230\257\350\203\275\350\276\271\345\223\255\350\276\271\345\201\232\345\206\263\347\255\226.md"
@@ -0,0 +1,75 @@
+# 成熟不是不哭，是能边哭边做决策
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：如果你把“是能边哭边做决策”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、从今天就能开始的三步动作
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把财务缓冲设置上限避免过载；
+
+　　第二，把执行窗口先降频再评估；
+
+　　第三，用可持续替代高压。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　只要不再重复同类错误，成长就会发生。
+## 四、别把旧赢法当成永久通行证
+
+　　可迁移能力比短期头衔更保值。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 五、收束：你该真正守住的东西
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　先止损，再进攻，通常更稳。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 16 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\274\232\345\277\215\357\274\214\346\230\257\344\274\232\350\260\210\346\235\241\344\273\266.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\274\232\345\277\215\357\274\214\346\230\257\344\274\232\350\260\210\346\235\241\344\273\266.md"
new file mode 100644
index 00000000..05d8372a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\347\206\237\344\270\215\346\230\257\344\274\232\345\277\215\357\274\214\346\230\257\344\274\232\350\260\210\346\235\241\344\273\266.md"
@@ -0,0 +1,75 @@
+# 成熟不是会忍，是会谈条件
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：在“是会谈条件”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、如果要改，从这里开始最省成本
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把项目范围放进固定复盘框架；
+
+　　第二，把注意力放进固定复盘框架；
+
+　　第三，用可重启替代一把梭哈。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、别把旧赢法当成永久通行证
+
+　　你不必最锋利，但一定要可重启。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　这不是消极，而是对长期负责。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 7 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\351\225\277\346\234\200\351\232\276\347\232\204\344\270\200\346\255\245\346\230\257\346\211\277\350\256\244\346\227\247\346\226\271\346\263\225\350\277\207\346\234\237.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\351\225\277\346\234\200\351\232\276\347\232\204\344\270\200\346\255\245\346\230\257\346\211\277\350\256\244\346\227\247\346\226\271\346\263\225\350\277\207\346\234\237.md"
new file mode 100644
index 00000000..bd93fa5f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\210\220\351\225\277\346\234\200\351\232\276\347\232\204\344\270\200\346\255\245\346\230\257\346\211\277\350\256\244\346\227\247\346\226\271\346\263\225\350\277\207\346\234\237.md"
@@ -0,0 +1,75 @@
+# 成长最难的一步是承认旧方法过期
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　关于“成长最难的一步是承认旧方法过期”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你追求的是进展，还是“看起来有进展”的感觉？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、先建立闭环，再谈效率神话
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把学习路径压到一周可验证；
+
+　　第二，把信息流减少到最小必要集；
+
+　　第三，用节律替代冲刺。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、真正的分水岭：纠偏速度
+
+　　可迁移能力比短期头衔更保值。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　把这件事想透，你会少走很多弯路。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 10 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\347\203\255\347\210\261\345\217\230\347\216\260\344\271\213\345\211\215\357\274\214\345\205\210\345\255\246\344\274\232\344\270\215\350\256\250\345\216\214\345\256\203.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\347\203\255\347\210\261\345\217\230\347\216\260\344\271\213\345\211\215\357\274\214\345\205\210\345\255\246\344\274\232\344\270\215\350\256\250\345\216\214\345\256\203.md"
new file mode 100644
index 00000000..46c64e92
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\347\203\255\347\210\261\345\217\230\347\216\260\344\271\213\345\211\215\357\274\214\345\205\210\345\255\246\344\274\232\344\270\215\350\256\250\345\216\214\345\256\203.md"
@@ -0,0 +1,75 @@
+# 把热爱变现之前，先学会不讨厌它
+
+　　这不是观点输出，而是一次认知止损。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“把热爱变现之前”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、这件事最常见的误读是什么
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　很多人会在把热爱变现之前下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、别停在共鸣，直接落成流程
+
+　　先把边界写清楚，再谈关系质量。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把项目范围放进固定复盘框架；
+
+　　第二，把信息流按优先级重排；
+
+　　第三，遇到越界立即处理。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、你最容易忽略的边界条件
+
+　　你不必最锋利，但一定要可重启。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　这不是消极，而是对长期负责。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 14 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\350\257\235\350\257\264\346\270\205\346\245\232\357\274\214\346\257\224\346\212\212\350\257\235\350\257\264\346\274\202\344\272\256\346\233\264\345\200\274\351\222\261.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\350\257\235\350\257\264\346\270\205\346\245\232\357\274\214\346\257\224\346\212\212\350\257\235\350\257\264\346\274\202\344\272\256\346\233\264\345\200\274\351\222\261.md"
new file mode 100644
index 00000000..e31877b8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\212\212\350\257\235\350\257\264\346\270\205\346\245\232\357\274\214\346\257\224\346\212\212\350\257\235\350\257\264\346\274\202\344\272\256\346\233\264\345\200\274\351\222\261.md"
@@ -0,0 +1,75 @@
+# 把话说清楚，比把话说漂亮更值钱
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“把话说清楚”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　所以比把话说漂亮更值钱的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、代价为什么总在后期集中爆发
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　先止损，再进攻，通常更稳。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、把抽象建议拆成现实动作
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把日程密度限定在可恢复负荷；
+
+　　第二，把项目范围切到单线程推进；
+
+　　第三，用真实成本替代理想叙事。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、边界、止损与可重启能力
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 7 月 2 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\226\345\273\266\345\276\210\345\244\232\346\227\266\345\200\231\344\270\215\346\230\257\346\207\222\357\274\214\350\200\214\346\230\257\347\233\256\346\240\207\345\206\231\345\276\227\345\244\252\346\273\241.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\226\345\273\266\345\276\210\345\244\232\346\227\266\345\200\231\344\270\215\346\230\257\346\207\222\357\274\214\350\200\214\346\230\257\347\233\256\346\240\207\345\206\231\345\276\227\345\244\252\346\273\241.md"
new file mode 100644
index 00000000..1d8a28c8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\226\345\273\266\345\276\210\345\244\232\346\227\266\345\200\231\344\270\215\346\230\257\346\207\222\357\274\214\350\200\214\346\230\257\347\233\256\346\240\207\345\206\231\345\276\227\345\244\252\346\273\241.md"
@@ -0,0 +1,75 @@
+# 拖延很多时候不是懒，而是目标写得太满
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：关键不在懒，而在目标写得太满。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、第一步就错位，后面全是补丁
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、代价为什么总在后期集中爆发
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把消费冲动转成可追踪指标；
+
+　　第二，把作息边界减少到最小必要集；
+
+　　第三，遇到越界立即处理。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+## 四、长期主义不是口号，是结算方式
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　你当然可以继续硬扛，只是代价会按月结息。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 五、收束：你该真正守住的东西
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　而是目标写得太满最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 13 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\245\346\234\211\350\247\202\347\202\271\344\270\215\351\232\276\357\274\214\346\204\277\346\204\217\346\224\271\350\247\202\347\202\271\346\211\215\351\232\276.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\245\346\234\211\350\247\202\347\202\271\344\270\215\351\232\276\357\274\214\346\204\277\346\204\217\346\224\271\350\247\202\347\202\271\346\211\215\351\232\276.md"
new file mode 100644
index 00000000..33790fe9
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\213\245\346\234\211\350\247\202\347\202\271\344\270\215\351\232\276\357\274\214\346\204\277\346\204\217\346\224\271\350\247\202\347\202\271\346\211\215\351\232\276.md"
@@ -0,0 +1,75 @@
+# 拥有观点不难，愿意改观点才难
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：在“拥有观点不难”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、动作设计比情绪动员更关键
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把学习路径控制到固定时段；
+
+　　第二，把协作节奏设定触发即处理机制；
+
+　　第三，用证据替代自责。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　先止损，再进攻，通常更稳。
+## 四、长期主义不是口号，是结算方式
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、收束：你该真正守住的东西
+
+　　你不需要更狠，你需要更准。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　愿意改观点才难最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 24 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\227\251\350\265\267\345\271\266\344\270\215\351\253\230\347\272\247\357\274\214\347\250\263\345\256\232\350\212\202\345\276\213\346\211\215\351\253\230\347\272\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\227\251\350\265\267\345\271\266\344\270\215\351\253\230\347\272\247\357\274\214\347\250\263\345\256\232\350\212\202\345\276\213\346\211\215\351\253\230\347\272\247.md"
new file mode 100644
index 00000000..f855bea8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\227\251\350\265\267\345\271\266\344\270\215\351\253\230\347\272\247\357\274\214\347\250\263\345\256\232\350\212\202\345\276\213\346\211\215\351\253\230\347\272\247.md"
@@ -0,0 +1,75 @@
+# 早起并不高级，稳定节律才高级
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：多数人输在“早起并不高级”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、这件事最常见的误读是什么
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这层看清之后，你会发现很多纠结其实都能拆解。
+## 三、把抽象建议拆成现实动作
+
+　　先守住节律，再追求峰值表现。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把情绪触发器控制到固定时段；
+
+　　第二，把作息边界加入止损条件；
+
+　　第三，用减法替代堆料。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多人会在早起并不高级下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　当你开始按证据推进，焦虑会自然下降。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　当你愿意在早起并不高级多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 16 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\234\200\345\245\275\347\232\204\351\243\216\351\231\251\347\256\241\347\220\206\346\230\257\350\256\251\350\207\252\345\267\261\345\247\213\347\273\210\345\217\257\351\207\215\345\220\257.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\234\200\345\245\275\347\232\204\351\243\216\351\231\251\347\256\241\347\220\206\346\230\257\350\256\251\350\207\252\345\267\261\345\247\213\347\273\210\345\217\257\351\207\215\345\220\257.md"
new file mode 100644
index 00000000..4b27126d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\234\200\345\245\275\347\232\204\351\243\216\351\231\251\347\256\241\347\220\206\346\230\257\350\256\251\350\207\252\345\267\261\345\247\213\347\273\210\345\217\257\351\207\215\345\220\257.md"
@@ -0,0 +1,75 @@
+# 最好的风险管理是让自己始终可重启
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“最”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　最最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　所以最的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、把抽象建议拆成现实动作
+
+　　先把输入源降噪，再谈深度输出。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把主目标按优先级重排；
+
+　　第二，把主目标控制到固定时段；
+
+　　第三，用可持续替代高压。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　别让短期体感绑架长期决策。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 30 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\250\241\344\273\277\351\253\230\346\211\213\346\234\200\345\256\271\346\230\223\345\277\275\347\225\245\347\232\204\346\230\257\347\272\246\346\235\237\346\235\241\344\273\266.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\250\241\344\273\277\351\253\230\346\211\213\346\234\200\345\256\271\346\230\223\345\277\275\347\225\245\347\232\204\346\230\257\347\272\246\346\235\237\346\235\241\344\273\266.md"
new file mode 100644
index 00000000..4a6d82a2
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\346\250\241\344\273\277\351\253\230\346\211\213\346\234\200\345\256\271\346\230\223\345\277\275\347\225\245\347\232\204\346\230\257\347\272\246\346\235\237\346\235\241\344\273\266.md"
@@ -0,0 +1,75 @@
+# 模仿高手最容易忽略的是约束条件
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你说自己没时间，会不会其实是边界太便宜？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　当你愿意在模多花一点耐心，后面的很多冲突会自动降级。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　所以模的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、如果要改，从这里开始最省成本
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把输入渠道设定触发即处理机制；
+
+　　第二，把输入渠道压到一周可验证；
+
+　　第三，用慢变量替代热点追逐。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　你真正要拿回来的，是选择权。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 四、真正的分水岭：纠偏速度
+
+　　越想稳，越要学会阶段性止损。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　先做对，再做快，这几乎永远不会错。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+## 五、最后回到最朴素的算术
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 19 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\213\254\345\244\204\344\270\215\346\230\257\347\226\227\344\274\244\357\274\214\345\256\203\346\233\264\345\203\217\344\270\200\346\254\241\345\206\205\351\203\250\345\256\241\350\256\241.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\213\254\345\244\204\344\270\215\346\230\257\347\226\227\344\274\244\357\274\214\345\256\203\346\233\264\345\203\217\344\270\200\346\254\241\345\206\205\351\203\250\345\256\241\350\256\241.md"
new file mode 100644
index 00000000..1a772f21
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\213\254\345\244\204\344\270\215\346\230\257\347\226\227\344\274\244\357\274\214\345\256\203\346\233\264\345\203\217\344\270\200\346\254\241\345\206\205\351\203\250\345\256\241\350\256\241.md"
@@ -0,0 +1,75 @@
+# 独处不是疗伤，它更像一次内部审计
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：在“它更像一次内部审计”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　当你愿意在独处不是疗伤多花一点耐心，后面的很多冲突会自动降级。
+## 三、把抽象建议拆成现实动作
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把承诺清单设置上限避免过载；
+
+　　第二，把作息边界按优先级重排；
+
+　　第三，用边界替代讨好。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　很多人会在独处不是疗伤下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　这条路不花哨，但它靠谱。
+## 四、边界、止损与可重启能力
+
+　　稳定不是不变，而是持续适配。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　这不是消极，而是对长期负责。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、收束：你该真正守住的东西
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 17 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\344\274\230\345\214\226\347\232\204\345\205\263\351\224\256\344\270\215\346\230\257\345\267\245\345\205\267\345\215\207\347\272\247\357\274\214\350\200\214\346\230\257\346\221\251\346\223\246\351\231\215\347\272\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\344\274\230\345\214\226\347\232\204\345\205\263\351\224\256\344\270\215\346\230\257\345\267\245\345\205\267\345\215\207\347\272\247\357\274\214\350\200\214\346\230\257\346\221\251\346\223\246\351\231\215\347\272\247.md"
new file mode 100644
index 00000000..b3ce631d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\344\274\230\345\214\226\347\232\204\345\205\263\351\224\256\344\270\215\346\230\257\345\267\245\345\205\267\345\215\207\347\272\247\357\274\214\350\200\214\346\230\257\346\221\251\346\223\246\351\231\215\347\272\247.md"
@@ -0,0 +1,75 @@
+# 生活优化的关键不是工具升级，而是摩擦降级
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：关键不在工具升级，而在摩擦降级。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、先谈模型，不急着谈技巧
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、代价为什么总在后期集中爆发
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、如果要改，从这里开始最省成本
+
+　　先把输入源降噪，再谈深度输出。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把日程密度先做最难的一步；
+
+　　第二，把协作节奏绑定到明确截止日；
+
+　　第三，用低摩擦替代硬扛。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多人会在而是摩擦降级下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、边界、止损与可重启能力
+
+　　你不必最锋利，但一定要可重启。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+## 五、如果只记住一句话，我希望是这个
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 14 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\350\264\250\351\207\217\346\217\220\345\215\207\345\276\200\345\276\200\344\273\216\345\207\217\345\260\221\346\257\224\350\276\203\345\274\200\345\247\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\350\264\250\351\207\217\346\217\220\345\215\207\345\276\200\345\276\200\344\273\216\345\207\217\345\260\221\346\257\224\350\276\203\345\274\200\345\247\213.md"
new file mode 100644
index 00000000..56b44c97
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\224\237\346\264\273\350\264\250\351\207\217\346\217\220\345\215\207\345\276\200\345\276\200\344\273\216\345\207\217\345\260\221\346\257\224\350\276\203\345\274\200\345\247\213.md"
@@ -0,0 +1,75 @@
+# 生活质量提升往往从减少比较开始
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：如果你把“生”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　系统健康，比一次高光重要得多。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　当你愿意在生多花一点耐心，后面的很多冲突会自动降级。
+## 三、先建立闭环，再谈效率神话
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把输出节奏设置上限避免过载；
+
+　　第二，把承诺清单限定在可恢复负荷；
+
+　　第三，每月重算一次策略。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　这条路不花哨，但它靠谱。
+## 四、长期主义不是口号，是结算方式
+
+　　越想稳，越要学会阶段性止损。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　这不是消极，而是对长期负责。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 28 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\225\214\351\231\220\346\204\237\345\274\261\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\350\257\257\346\212\212\345\226\204\346\204\217\345\275\223\344\271\211\345\212\241.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\225\214\351\231\220\346\204\237\345\274\261\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\350\257\257\346\212\212\345\226\204\346\204\217\345\275\223\344\271\211\345\212\241.md"
new file mode 100644
index 00000000..82b4074f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\225\214\351\231\220\346\204\237\345\274\261\347\232\204\344\272\272\346\234\200\345\256\271\346\230\223\350\257\257\346\212\212\345\226\204\346\204\217\345\275\223\344\271\211\345\212\241.md"
@@ -0,0 +1,75 @@
+# 界限感弱的人最容易误把善意当义务
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　关于“界限感弱的人最容易误把善意当义务”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：“界”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　所以界的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、把观点变动作：给你可执行的改法
+
+　　先把边界写清楚，再谈关系质量。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把复盘节点限定在可恢复负荷；
+
+　　第二，把项目范围减少到最小必要集；
+
+　　第三，每月重算一次策略。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　很多人会在界下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、真正的分水岭：纠偏速度
+
+　　可恢复性比单次高光更关键。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　这不是消极，而是对长期负责。
+## 五、如果只记住一句话，我希望是这个
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　先止损，再进攻，通常更稳。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 21 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\233\256\346\240\207\345\244\252\345\244\247\346\227\266\346\204\217\345\277\227\345\212\233\344\274\232\350\207\252\345\212\250\347\275\242\345\267\245.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\233\256\346\240\207\345\244\252\345\244\247\346\227\266\346\204\217\345\277\227\345\212\233\344\274\232\350\207\252\345\212\250\347\275\242\345\267\245.md"
new file mode 100644
index 00000000..69f7a47e
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\233\256\346\240\207\345\244\252\345\244\247\346\227\266\346\204\217\345\277\227\345\212\233\344\274\232\350\207\252\345\212\250\347\275\242\345\267\245.md"
@@ -0,0 +1,75 @@
+# 目标太大时意志力会自动罢工
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：“目”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、先谈模型，不急着谈技巧
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　目最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、把抽象建议拆成现实动作
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把执行窗口设定触发即处理机制；
+
+　　第二，把复盘节点写成明文规则；
+
+　　第三，用反馈闭环替代盲做。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　你真正要拿回来的，是选择权。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　稳定不是不变，而是持续适配。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　把这层看清之后，你会发现很多纠结其实都能拆解。
+
+　　很多人会在目下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、收束：你该真正守住的东西
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　当你愿意在目多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 5 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\201\351\222\261\344\270\215\347\255\211\344\272\216\347\220\206\350\264\242\357\274\214\345\273\266\350\277\237\351\224\231\350\257\257\346\266\210\350\264\271\346\211\215\346\230\257\347\220\206\350\264\242\350\265\267\347\202\271.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\201\351\222\261\344\270\215\347\255\211\344\272\216\347\220\206\350\264\242\357\274\214\345\273\266\350\277\237\351\224\231\350\257\257\346\266\210\350\264\271\346\211\215\346\230\257\347\220\206\350\264\242\350\265\267\347\202\271.md"
new file mode 100644
index 00000000..ca245f46
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\201\351\222\261\344\270\215\347\255\211\344\272\216\347\220\206\350\264\242\357\274\214\345\273\266\350\277\237\351\224\231\350\257\257\346\266\210\350\264\271\346\211\215\346\230\257\347\220\206\350\264\242\350\265\267\347\202\271.md"
@@ -0,0 +1,75 @@
+# 省钱不等于理财，延迟错误消费才是理财起点
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：多数人输在“省钱不等于理财”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　很多人会在省钱不等于理财下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　当你愿意在省钱不等于理财多花一点耐心，后面的很多冲突会自动降级。
+## 二、代价为什么总在后期集中爆发
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这不是消极，而是对长期负责。
+## 三、动作设计比情绪动员更关键
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把注意力加入止损条件；
+
+　　第二，把任务清单按优先级重排；
+
+　　第三，用长期账替代短期爽。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　只要不再重复同类错误，成长就会发生。
+## 四、真正的分水岭：纠偏速度
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、最后一句狠话：先做对，再做快
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 5 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\345\217\257\346\200\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\346\230\257\346\210\220\345\212\237\346\250\241\346\235\277\346\210\220\347\230\276.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\345\217\257\346\200\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\346\230\257\346\210\220\345\212\237\346\250\241\346\235\277\346\210\220\347\230\276.md"
new file mode 100644
index 00000000..258fcc04
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\345\217\257\346\200\225\347\232\204\344\270\215\346\230\257\345\244\261\350\264\245\357\274\214\346\230\257\346\210\220\345\212\237\346\250\241\346\235\277\346\210\220\347\230\276.md"
@@ -0,0 +1,75 @@
+# 真正可怕的不是失败，是成功模板成瘾
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：“是成功模板成瘾”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、从机制看，这里到底错在哪
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　是成功模板成瘾最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、先降摩擦，再提强度
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把情绪触发器默认延迟非关键项；
+
+　　第二，把沟通窗口设定触发即处理机制；
+
+　　第三，用慢变量替代热点追逐。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　别让短期体感绑架长期决策。
+## 四、边界、止损与可重启能力
+
+　　稳定不是不变，而是持续适配。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、如果只记住一句话，我希望是这个
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　很多人会在是成功模板成瘾下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 19 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\345\255\246\344\271\240\344\270\215\346\230\257\350\276\223\345\205\245\357\274\214\350\200\214\346\230\257\345\206\215\350\241\250\350\276\276.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\345\255\246\344\271\240\344\270\215\346\230\257\350\276\223\345\205\245\357\274\214\350\200\214\346\230\257\345\206\215\350\241\250\350\276\276.md"
new file mode 100644
index 00000000..210868c8
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\345\255\246\344\271\240\344\270\215\346\230\257\350\276\223\345\205\245\357\274\214\350\200\214\346\230\257\345\206\215\350\241\250\350\276\276.md"
@@ -0,0 +1,75 @@
+# 真正的学习不是输入，而是再表达
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　关于“真正的学习不是输入，而是再表达”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：关键不在输入，而在再表达。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、第一步就错位，后面全是补丁
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　真正的学习不是输入最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　所以真正的学习不是输入的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 三、动作设计比情绪动员更关键
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把复盘节点按优先级重排；
+
+　　第二，把任务清单减少到最小必要集；
+
+　　第三，用边界替代讨好。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　很多人会在真正的学习不是输入下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、把这层做对，很多问题会自动降级
+
+　　可迁移能力比短期头衔更保值。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　最后回到最朴素的答案：先做对，再做快。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 3 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\346\213\226\345\273\266\346\230\257\345\257\271\350\272\253\344\273\275\351\243\216\351\231\251\347\232\204\345\233\236\351\201\277.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\346\213\226\345\273\266\346\230\257\345\257\271\350\272\253\344\273\275\351\243\216\351\231\251\347\232\204\345\233\236\351\201\277.md"
new file mode 100644
index 00000000..46baa0fb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\346\213\226\345\273\266\346\230\257\345\257\271\350\272\253\344\273\275\351\243\216\351\231\251\347\232\204\345\233\236\351\201\277.md"
@@ -0,0 +1,75 @@
+# 真正的拖延是对身份风险的回避
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　关于“真正的拖延是对身份风险的回避”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：在“真”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、别急着解决，先确认问题定义有没有错
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、代价为什么总在后期集中爆发
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这条路不花哨，但它靠谱。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　当你愿意在真多花一点耐心，后面的很多冲突会自动降级。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把项目范围放进固定复盘框架；
+
+　　第二，把协作节奏压到一周可验证；
+
+　　第三，用结果替代表演。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+## 四、稳定不是不变，而是持续适配
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　把问题协议化，很多摩擦会提前消失。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 15 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\350\207\252\345\276\213\346\230\257\346\217\220\345\211\215\350\256\276\350\256\241\350\257\261\346\203\221\347\216\257\345\242\203.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\350\207\252\345\276\213\346\230\257\346\217\220\345\211\215\350\256\276\350\256\241\350\257\261\346\203\221\347\216\257\345\242\203.md"
new file mode 100644
index 00000000..d7af766d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\232\204\350\207\252\345\276\213\346\230\257\346\217\220\345\211\215\350\256\276\350\256\241\350\257\261\346\203\221\347\216\257\345\242\203.md"
@@ -0,0 +1,75 @@
+# 真正的自律是提前设计诱惑环境
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：“真”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、别停在共鸣，直接落成流程
+
+　　先把边界写清楚，再谈关系质量。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把主目标设置上限避免过载；
+
+　　第二，把输出节奏减少到最小必要集；
+
+　　第三，用边界替代讨好。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、你最容易忽略的边界条件
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、最后回到最朴素的算术
+
+　　把这件事想透，你会少走很多弯路。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 12 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\250\200\347\274\272\347\232\204\344\270\215\346\230\257\350\265\204\346\272\220\357\274\214\346\230\257\346\212\212\350\265\204\346\272\220\345\217\230\347\273\223\346\236\234\347\232\204\346\216\245\345\217\243.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\250\200\347\274\272\347\232\204\344\270\215\346\230\257\350\265\204\346\272\220\357\274\214\346\230\257\346\212\212\350\265\204\346\272\220\345\217\230\347\273\223\346\236\234\347\232\204\346\216\245\345\217\243.md"
new file mode 100644
index 00000000..44cfcfa3
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\347\250\200\347\274\272\347\232\204\344\270\215\346\230\257\350\265\204\346\272\220\357\274\214\346\230\257\346\212\212\350\265\204\346\272\220\345\217\230\347\273\223\346\236\234\347\232\204\346\216\245\345\217\243.md"
@@ -0,0 +1,75 @@
+# 真正稀缺的不是资源，是把资源变结果的接口
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：“真正稀缺的不是资源”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、先谈模型，不急着谈技巧
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　很多人会在真正稀缺的不是资源下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以真正稀缺的不是资源的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把消费冲动控制到固定时段；
+
+　　第二，把协作节奏先降频再评估；
+
+　　第三，用结果替代表演。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　真正稀缺的不是资源最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 四、长期主义不是口号，是结算方式
+
+　　稳定不是不变，而是持续适配。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　当你开始按证据推进，焦虑会自然下降。
+## 五、最后一句狠话：先做对，再做快
+
+　　你不需要更狠，你需要更准。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　当你愿意在真正稀缺的不是资源多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 24 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\351\253\230\347\272\247\347\232\204\345\226\204\350\211\257\357\274\214\346\230\257\345\270\246\346\213\222\347\273\235\345\212\237\350\203\275\347\232\204\345\226\204\350\211\257.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\351\253\230\347\272\247\347\232\204\345\226\204\350\211\257\357\274\214\346\230\257\345\270\246\346\213\222\347\273\235\345\212\237\350\203\275\347\232\204\345\226\204\350\211\257.md"
new file mode 100644
index 00000000..42a67663
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\234\237\346\255\243\351\253\230\347\272\247\347\232\204\345\226\204\350\211\257\357\274\214\346\230\257\345\270\246\346\213\222\347\273\235\345\212\237\350\203\275\347\232\204\345\226\204\350\211\257.md"
@@ -0,0 +1,75 @@
+# 真正高级的善良，是带拒绝功能的善良
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：在“真正高级的善良”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　很多人会在是带拒绝功能的善良下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、从今天就能开始的三步动作
+
+　　先把边界写清楚，再谈关系质量。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把项目范围先降频再评估；
+
+　　第二，把关键任务控制到固定时段；
+
+　　第三，用小迭代替代大跃进。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、别把旧赢法当成永久通行证
+
+　　越想稳，越要学会阶段性止损。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、回到结论：这件事值得你马上重算
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 23 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\244\276\344\272\244\350\266\212\345\244\232\344\270\215\344\270\200\345\256\232\346\234\272\344\274\232\350\266\212\345\244\232\357\274\214\345\217\257\350\203\275\345\231\252\345\243\260\350\266\212\345\244\232.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\244\276\344\272\244\350\266\212\345\244\232\344\270\215\344\270\200\345\256\232\346\234\272\344\274\232\350\266\212\345\244\232\357\274\214\345\217\257\350\203\275\345\231\252\345\243\260\350\266\212\345\244\232.md"
new file mode 100644
index 00000000..78db1030
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\244\276\344\272\244\350\266\212\345\244\232\344\270\215\344\270\200\345\256\232\346\234\272\344\274\232\350\266\212\345\244\232\357\274\214\345\217\257\350\203\275\345\231\252\345\243\260\350\266\212\345\244\232.md"
@@ -0,0 +1,75 @@
+# 社交越多不一定机会越多，可能噪声越多
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：在“可能噪声越多”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、第一步就错位，后面全是补丁
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多人会在社交越多不一定机会越多下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、这件事落地，核心不在狠而在稳
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把情绪触发器转成可追踪指标；
+
+　　第二，把作息边界加上结果验收标准；
+
+　　第三，用慢变量替代热点追逐。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　真正省力的方法，通常都先从校准开始。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、把这层做对，很多问题会自动降级
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、最后一句狠话：先做对，再做快
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　这条路不花哨，但它靠谱。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 29 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\250\263\345\256\232\345\267\245\344\275\234\345\271\266\344\270\215\345\255\230\345\234\250\357\274\214\347\250\263\345\256\232\350\203\275\345\212\233\346\211\215\345\255\230\345\234\250.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\250\263\345\256\232\345\267\245\344\275\234\345\271\266\344\270\215\345\255\230\345\234\250\357\274\214\347\250\263\345\256\232\350\203\275\345\212\233\346\211\215\345\255\230\345\234\250.md"
new file mode 100644
index 00000000..8d686b12
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\347\250\263\345\256\232\345\267\245\344\275\234\345\271\266\344\270\215\345\255\230\345\234\250\357\274\214\347\250\263\345\256\232\350\203\275\345\212\233\346\211\215\345\255\230\345\234\250.md"
@@ -0,0 +1,75 @@
+# 稳定工作并不存在，稳定能力才存在
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：如果你把“稳定工作并不存在”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以稳定工作并不存在的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、如果要改，从这里开始最省成本
+
+　　先守住节律，再追求峰值表现。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把日程密度设置上限避免过载；
+
+　　第二，把输出节奏切到单线程推进；
+
+　　第三，遇到越界立即处理。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　这一步看起来不酷，但最值钱。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多人会在稳定工作并不存在下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 16 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\344\270\232\350\275\254\345\236\213\344\270\215\346\230\257\350\267\263\346\247\275\345\212\250\344\275\234\357\274\214\350\200\214\346\230\257\350\203\275\345\212\233\350\277\201\347\247\273\345\267\245\347\250\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\344\270\232\350\275\254\345\236\213\344\270\215\346\230\257\350\267\263\346\247\275\345\212\250\344\275\234\357\274\214\350\200\214\346\230\257\350\203\275\345\212\233\350\277\201\347\247\273\345\267\245\347\250\213.md"
new file mode 100644
index 00000000..9788b5cc
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\344\270\232\350\275\254\345\236\213\344\270\215\346\230\257\350\267\263\346\247\275\345\212\250\344\275\234\357\274\214\350\200\214\346\230\257\350\203\275\345\212\233\350\277\201\347\247\273\345\267\245\347\250\213.md"
@@ -0,0 +1,75 @@
+# 职业转型不是跳槽动作，而是能力迁移工程
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：关键不在跳槽动作，而在能力迁移工程。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　所以职业转型不是跳槽动作的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 二、代价为什么总在后期集中爆发
+
+　　问题如果一直靠忍，最后一般不会消失，只会升级。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、从今天就能开始的三步动作
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把复盘节点减少到最小必要集；
+
+　　第二，把承诺清单设定触发即处理机制；
+
+　　第三，用长期账替代短期爽。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、你最容易忽略的边界条件
+
+　　可恢复性比单次高光更关键。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　很多人会在职业转型不是跳槽动作下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　先止损，再进攻，通常更稳。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 8 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\345\234\272\351\207\214\347\232\204\347\234\237\350\257\232\351\234\200\350\246\201\347\277\273\350\257\221\346\210\220\347\273\223\346\236\234\350\257\255\350\250\200.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\345\234\272\351\207\214\347\232\204\347\234\237\350\257\232\351\234\200\350\246\201\347\277\273\350\257\221\346\210\220\347\273\223\346\236\234\350\257\255\350\250\200.md"
new file mode 100644
index 00000000..07bb82cb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\201\214\345\234\272\351\207\214\347\232\204\347\234\237\350\257\232\351\234\200\350\246\201\347\277\273\350\257\221\346\210\220\347\273\223\346\236\234\350\257\255\350\250\200.md"
@@ -0,0 +1,75 @@
+# 职场里的真诚需要翻译成结果语言
+
+　　这不是观点输出，而是一次认知止损。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：“职”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、第一步就错位，后面全是补丁
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　当你愿意在职多花一点耐心，后面的很多冲突会自动降级。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、别停在共鸣，直接落成流程
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把情绪触发器绑定到明确截止日；
+
+　　第二，把日程密度转成可追踪指标；
+
+　　第三，用反馈闭环替代盲做。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、这一步不酷，但最值钱
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　先做对，再做快，这几乎永远不会错。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、回到结论：这件事值得你马上重算
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　先止损，再进攻，通常更稳。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 18 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\345\244\215\345\210\251\347\232\204\345\211\215\346\217\220\346\230\257\346\203\205\347\273\252\347\216\260\351\207\221\346\265\201\344\270\272\346\255\243.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\345\244\215\345\210\251\347\232\204\345\211\215\346\217\220\346\230\257\346\203\205\347\273\252\347\216\260\351\207\221\346\265\201\344\270\272\346\255\243.md"
new file mode 100644
index 00000000..8c0c3c40
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\345\244\215\345\210\251\347\232\204\345\211\215\346\217\220\346\230\257\346\203\205\347\273\252\347\216\260\351\207\221\346\265\201\344\270\272\346\255\243.md"
@@ -0,0 +1,75 @@
+# 能力复利的前提是情绪现金流为正
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　关于“能力复利的前提是情绪现金流为正”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：多数人输在“能”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+## 三、把观点变动作：给你可执行的改法
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把日程密度减少到最小必要集；
+
+　　第二，把关键任务设定触发即处理机制；
+
+　　第三，用长期账替代短期爽。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、稳定不是不变，而是持续适配
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　能最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　所以能的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 23 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\346\210\220\351\225\277\346\234\200\345\277\253\347\232\204\346\227\266\345\200\231\345\276\200\345\276\200\346\234\200\344\270\215\344\275\223\351\235\242.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\346\210\220\351\225\277\346\234\200\345\277\253\347\232\204\346\227\266\345\200\231\345\276\200\345\276\200\346\234\200\344\270\215\344\275\223\351\235\242.md"
new file mode 100644
index 00000000..0b697c37
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\203\275\345\212\233\346\210\220\351\225\277\346\234\200\345\277\253\347\232\204\346\227\266\345\200\231\345\276\200\345\276\200\346\234\200\344\270\215\344\275\223\351\235\242.md"
@@ -0,0 +1,75 @@
+# 能力成长最快的时候往往最不体面
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、把叙事翻过来，你会看到另一套真相
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　你会越来越不敢改，因为改意味着承认过去投入有一部分无效。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、把观点变动作：给你可执行的改法
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把作息边界写成明文规则；
+
+　　第二，把情绪触发器加入止损条件；
+
+　　第三，用可重启替代一把梭哈。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、稳定不是不变，而是持续适配
+
+　　可迁移能力比短期头衔更保值。
+
+　　有人会觉得这太冷。其实这只是边界清晰。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、最后一句狠话：先做对，再做快
+
+　　你不需要更狠，你需要更准。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　这条路不花哨，但它靠谱。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 9 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\345\260\212\350\277\207\351\253\230\345\222\214\350\207\252\345\215\221\350\277\207\346\267\261\345\270\270\345\270\270\345\220\214\346\272\220.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\345\260\212\350\277\207\351\253\230\345\222\214\350\207\252\345\215\221\350\277\207\346\267\261\345\270\270\345\270\270\345\220\214\346\272\220.md"
new file mode 100644
index 00000000..c2b76215
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\345\260\212\350\277\207\351\253\230\345\222\214\350\207\252\345\215\221\350\277\207\346\267\261\345\270\270\345\270\270\345\220\214\346\272\220.md"
@@ -0,0 +1,75 @@
+# 自尊过高和自卑过深常常同源
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　标题看起来像情绪表达，实际上是一个结构性问题。
+
+　　先给结论：在“自”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、从机制看，这里到底错在哪
+
+　　多数人把这题当成“我够不够狠”的性格题，于是拼命加意志力。问题是，意志力是燃料，不是方向盘。方向盘打错了，油门越大越危险。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+## 三、把观点变动作：给你可执行的改法
+
+　　先守住节律，再追求峰值表现。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把复盘节点设定触发即处理机制；
+
+　　第二，把情绪触发器绑定到明确截止日；
+
+　　第三，每周固定一次复盘。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+## 四、别把旧赢法当成永久通行证
+
+　　你不必最锋利，但一定要可重启。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、最后回到最朴素的算术
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　从今天开始，少一点自我感动，多一点证据导向。
+
+　　先止损，再进攻，通常更稳。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 13 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\200\200\347\226\221\346\234\252\345\277\205\346\230\257\345\235\217\344\272\213\357\274\214\345\244\261\345\216\273\346\240\241\345\207\206\346\211\215\346\230\257\345\235\217\344\272\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\200\200\347\226\221\346\234\252\345\277\205\346\230\257\345\235\217\344\272\213\357\274\214\345\244\261\345\216\273\346\240\241\345\207\206\346\211\215\346\230\257\345\235\217\344\272\213.md"
new file mode 100644
index 00000000..39202f3a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\200\200\347\226\221\346\234\252\345\277\205\346\230\257\345\235\217\344\272\213\357\274\214\345\244\261\345\216\273\346\240\241\345\207\206\346\211\215\346\230\257\345\235\217\344\272\213.md"
@@ -0,0 +1,75 @@
+# 自我怀疑未必是坏事，失去校准才是坏事
+
+　　很多看上去正确的做法，只在短期成立；周期一拉长，就会暴露代价。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：多数人输在“自我怀疑未必是坏事”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、先谈模型，不急着谈技巧
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　失去校准才是坏事最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　很多人会在失去校准才是坏事下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 三、把观点变动作：给你可执行的改法
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把任务清单转成可追踪指标；
+
+　　第二，把情绪触发器先降频再评估；
+
+　　第三，用规则替代临场猜测。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、你最容易忽略的边界条件
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　有人会觉得这太功利。我反而觉得，这叫长期负责。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、回到结论：这件事值得你马上重算
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 22 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\204\237\345\212\250\346\230\257\346\234\200\350\264\265\347\232\204\347\224\237\344\272\247\345\212\233\347\250\216.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\204\237\345\212\250\346\230\257\346\234\200\350\264\265\347\232\204\347\224\237\344\272\247\345\212\233\347\250\216.md"
new file mode 100644
index 00000000..0378b718
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\346\210\221\346\204\237\345\212\250\346\230\257\346\234\200\350\264\265\347\232\204\347\224\237\344\272\247\345\212\233\347\250\216.md"
@@ -0,0 +1,75 @@
+# 自我感动是最贵的生产力税
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、把抽象建议拆成现实动作
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把沟通窗口控制到固定时段；
+
+　　第二，把消费冲动放进固定复盘框架；
+
+　　第三，用动作证据替代口头计划。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、真正的分水岭：纠偏速度
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、最后一句狠话：先做对，再做快
+
+　　把这件事想透，你会少走很多弯路。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　先止损，再进攻，通常更稳。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 30 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\347\224\261\350\201\214\344\270\232\346\234\200\345\244\247\347\232\204\351\227\250\346\247\233\346\230\257\350\207\252\346\210\221\347\273\223\347\256\227\350\203\275\345\212\233.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\347\224\261\350\201\214\344\270\232\346\234\200\345\244\247\347\232\204\351\227\250\346\247\233\346\230\257\350\207\252\346\210\221\347\273\223\347\256\227\350\203\275\345\212\233.md"
new file mode 100644
index 00000000..3dc87834
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\207\252\347\224\261\350\201\214\344\270\232\346\234\200\345\244\247\347\232\204\351\227\250\346\247\233\346\230\257\350\207\252\346\210\221\347\273\223\347\256\227\350\203\275\345\212\233.md"
@@ -0,0 +1,75 @@
+# 自由职业最大的门槛是自我结算能力
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　你先别急着同意我，先拿自己的生活当样本做压力测试。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、先谈模型，不急着谈技巧
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、先建立闭环，再谈效率神话
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把项目范围默认延迟非关键项；
+
+　　第二，把日程密度放进固定复盘框架；
+
+　　第三，用减法替代堆料。
+
+　　重点不是做很多，而是每周留下清晰证据。证据一稳定，焦虑会降一半。
+
+　　很多人会在自下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、你最容易忽略的边界条件
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、如果只记住一句话，我希望是这个
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 24 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\345\212\250\344\271\220\350\247\202\346\257\224\346\202\262\350\247\202\346\233\264\345\215\261\351\231\251.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\345\212\250\344\271\220\350\247\202\346\257\224\346\202\262\350\247\202\346\233\264\345\215\261\351\231\251.md"
new file mode 100644
index 00000000..9611a957
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\345\212\250\344\271\220\350\247\202\346\257\224\346\202\262\350\247\202\346\233\264\345\215\261\351\231\251.md"
@@ -0,0 +1,75 @@
+# 被动乐观比悲观更危险
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：在“被”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、第一步就错位，后面全是补丁
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　很多疲惫并非来自工作量，而是来自重复返工。返工越多，人的判断越钝。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　真正省力的方法，通常都先从校准开始。
+## 三、先降摩擦，再提强度
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把关键任务写成明文规则；
+
+　　第二，把信息流先降频再评估；
+
+　　第三，每周固定一次复盘。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、你最容易忽略的边界条件
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、收束：你该真正守住的东西
+
+　　把这件事想透，你会少走很多弯路。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　很多人会在被下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　先止损，再进攻，通常更稳。
+
+　　所以被的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 2 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\347\234\213\350\247\201\345\271\266\344\270\215\347\255\211\344\272\216\350\242\253\347\220\206\350\247\243.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\347\234\213\350\247\201\345\271\266\344\270\215\347\255\211\344\272\216\350\242\253\347\220\206\350\247\243.md"
new file mode 100644
index 00000000..fc8afa04
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\242\253\347\234\213\350\247\201\345\271\266\344\270\215\347\255\211\344\272\216\350\242\253\347\220\206\350\247\243.md"
@@ -0,0 +1,75 @@
+# 被看见并不等于被理解
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：在“被”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你现在做的每件事，真的都值得你的注意力吗？
+
+## 一、表层很合理，底层很昂贵
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　当你愿意在被多花一点耐心，后面的很多冲突会自动降级。
+## 二、代价为什么总在后期集中爆发
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、别停在共鸣，直接落成流程
+
+　　先把输入源降噪，再谈深度输出。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把人际暴露按优先级重排；
+
+　　第二，把沟通窗口加上结果验收标准；
+
+　　第三，用长期账替代短期爽。
+
+　　把复杂问题拆成小闭环，是最务实的勇敢。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、这一步不酷，但最值钱
+
+　　可恢复性比单次高光更关键。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 26 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\256\241\345\210\222\350\266\212\347\273\206\346\234\211\346\227\266\350\266\212\345\256\271\346\230\223\345\244\261\350\264\245.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\256\241\345\210\222\350\266\212\347\273\206\346\234\211\346\227\266\350\266\212\345\256\271\346\230\223\345\244\261\350\264\245.md"
new file mode 100644
index 00000000..1b509e62
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\256\241\345\210\222\350\266\212\347\273\206\346\234\211\346\227\266\350\266\212\345\256\271\346\230\223\345\244\261\350\264\245.md"
@@ -0,0 +1,75 @@
+# 计划越细有时越容易失败
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：如果你把“计”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、从机制看，这里到底错在哪
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　当你愿意在计多花一点耐心，后面的很多冲突会自动降级。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、动作设计比情绪动员更关键
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　这题想拿结果，先把这三步落地：
+
+　　第一，把信息流设定触发即处理机制；
+
+　　第二，把信息流设定触发即处理机制；
+
+　　第三，用系统替代鸡血。
+
+　　这三步不酷，但它有个巨大优势：能持续执行。能持续，才有复利。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先止损，再进攻，通常更稳。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　可恢复性比单次高光更关键。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、给这篇文章一个现实结尾
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 31 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\200\274\351\222\261\347\232\204\345\212\237\350\203\275\344\270\215\346\230\257\350\256\260\345\277\206\357\274\214\350\200\214\346\230\257\346\217\220\351\227\256.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\200\274\351\222\261\347\232\204\345\212\237\350\203\275\344\270\215\346\230\257\350\256\260\345\277\206\357\274\214\350\200\214\346\230\257\346\217\220\351\227\256.md"
new file mode 100644
index 00000000..9e52d048
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\200\274\351\222\261\347\232\204\345\212\237\350\203\275\344\270\215\346\230\257\350\256\260\345\277\206\357\274\214\350\200\214\346\230\257\346\217\220\351\227\256.md"
@@ -0,0 +1,75 @@
+# 读书最值钱的功能不是记忆，而是提问
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　关于“读书最值钱的功能不是记忆，而是提问”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：关键不在记忆，而在提问。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　读书最值钱的功能不是记忆最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　先把代价结构画出来，再决定是不是继续原打法。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　你不需要一夜之间脱胎换骨。先改一个关键接口，整个链路会出现拐点。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把主目标转成可追踪指标；
+
+　　第二，把学习路径拆到当天可完成；
+
+　　第三，用可持续替代高压。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　你真正要拿回来的，是选择权。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多人会在读书最值钱的功能不是记忆下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、如果只记住一句话，我希望是这个
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 9 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\256\271\346\230\223\351\224\231\345\234\250\346\213\277\347\273\223\350\256\272\345\275\223\344\277\241\344\273\260.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\256\271\346\230\223\351\224\231\345\234\250\346\213\277\347\273\223\350\256\272\345\275\223\344\277\241\344\273\260.md"
new file mode 100644
index 00000000..2b231687
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\257\273\344\271\246\346\234\200\345\256\271\346\230\223\351\224\231\345\234\250\346\213\277\347\273\223\350\256\272\345\275\223\344\277\241\344\273\260.md"
@@ -0,0 +1,75 @@
+# 读书最容易错在拿结论当信仰
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：多数人输在“读”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、这件事最常见的误读是什么
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、路径依赖一旦形成，修复成本会飙升
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　很多人会在读下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先守住节律，再追求峰值表现。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把项目范围先降频再评估；
+
+　　第二，把消费冲动放进固定复盘框架；
+
+　　第三，用低摩擦替代硬扛。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　你真正要拿回来的，是选择权。
+## 四、这一步不酷，但最值钱
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　这件事没有神话，只有算术；算术做对了，人生就不会离谱。
+
+　　你会慢慢得到一种稀缺能力：不慌不忙地持续变好。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 5 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\260\210\346\225\210\347\216\207\345\211\215\345\205\210\350\260\210\345\201\245\345\272\267\344\275\231\351\242\235.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\260\210\346\225\210\347\216\207\345\211\215\345\205\210\350\260\210\345\201\245\345\272\267\344\275\231\351\242\235.md"
new file mode 100644
index 00000000..09cf7e75
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\260\210\346\225\210\347\216\207\345\211\215\345\205\210\350\260\210\345\201\245\345\272\267\344\275\231\351\242\235.md"
@@ -0,0 +1,75 @@
+# 谈效率前先谈健康余额
+
+　　如果你最近总觉得越忙越空，问题大概率不在意志力，而在系统参数。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“谈”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、先谈模型，不急着谈技巧
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　谈最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　系统健康，比一次高光重要得多。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、从今天就能开始的三步动作
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　说得再多不如做出来，先做这三步：
+
+　　第一，把主目标切到单线程推进；
+
+　　第二，把关键任务绑定到明确截止日；
+
+　　第三，用真实成本替代理想叙事。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　先止损，再进攻，通常更稳。
+## 四、稳定不是不变，而是持续适配
+
+　　越想稳，越要学会阶段性止损。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　你不需要更狠，你需要更准。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　所以谈的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 20 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\266\212\346\227\251\345\273\272\347\253\213\350\257\201\346\215\256\346\200\235\347\273\264\357\274\214\350\266\212\345\260\221\350\242\253\346\203\205\347\273\252\346\224\266\345\211\262.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\266\212\346\227\251\345\273\272\347\253\213\350\257\201\346\215\256\346\200\235\347\273\264\357\274\214\350\266\212\345\260\221\350\242\253\346\203\205\347\273\252\346\224\266\345\211\262.md"
new file mode 100644
index 00000000..2c13da25
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\266\212\346\227\251\345\273\272\347\253\213\350\257\201\346\215\256\346\200\235\347\273\264\357\274\214\350\266\212\345\260\221\350\242\253\346\203\205\347\273\252\346\224\266\345\211\262.md"
@@ -0,0 +1,75 @@
+# 越早建立证据思维，越少被情绪收割
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：在“越早建立证据思维”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、这件事最常见的误读是什么
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、这是慢性失血，不是一次性爆炸
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　你先别求完美，先把这三步跑通：
+
+　　第一，把复盘节点切到单线程推进；
+
+　　第二，把协作节奏设定触发即处理机制；
+
+　　第三，用慢变量替代热点追逐。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、边界、止损与可重启能力
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　越少被情绪收割最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 31 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\205\261\346\203\205\344\274\232\345\201\267\350\265\260\344\275\240\347\232\204\345\206\263\347\255\226\346\270\205\346\231\260\345\272\246.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\205\261\346\203\205\344\274\232\345\201\267\350\265\260\344\275\240\347\232\204\345\206\263\347\255\226\346\270\205\346\231\260\345\272\246.md"
new file mode 100644
index 00000000..ebef449a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\205\261\346\203\205\344\274\232\345\201\267\350\265\260\344\275\240\347\232\204\345\206\263\347\255\226\346\270\205\346\231\260\345\272\246.md"
@@ -0,0 +1,75 @@
+# 过度共情会偷走你的决策清晰度
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“过”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、这件事最常见的误读是什么
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　过最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　这类问题最阴险的一点，是早期反馈经常不差。你会误以为路没错，所以继续加码。
+
+　　你不能靠口号穿越周期，只能靠结构。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先把边界写清楚，再谈关系质量。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把沟通窗口绑定到明确截止日；
+
+　　第二，把信息流控制到固定时段；
+
+　　第三，每周固定一次复盘。
+
+　　别追求一次性逆转，先追求连续小胜。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 四、稳定不是不变，而是持续适配
+
+　　可迁移能力比短期头衔更保值。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　很多人会在过下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　当你开始按证据推进，焦虑会自然下降。
+## 五、回到结论：这件事值得你马上重算
+
+　　当你不再被默认叙事牵着走，人生会进入稳中有进区间。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　你真正要拿回来的，是选择权。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 7 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\244\215\347\233\230\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\241\214\345\212\250\350\202\214\350\202\211.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\244\215\347\233\230\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\241\214\345\212\250\350\202\214\350\202\211.md"
new file mode 100644
index 00000000..3a509535
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\345\244\215\347\233\230\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\241\214\345\212\250\350\202\214\350\202\211.md"
@@ -0,0 +1,75 @@
+# 过度复盘会让你失去行动肌肉
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：多数人输在“过”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、从机制看，这里到底错在哪
+
+　　你以为自己在守住原则，实际上可能只是在守住旧脚本。旧脚本在旧环境里有效，不代表在现在有效。
+
+　　越是关键阶段，越不能把“感觉”当作唯一指标。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　当你开始按证据推进，焦虑会自然下降。
+## 三、你真正需要的是“能跑起来”的版本
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把复盘节点改为低成本试错；
+
+　　第二，把项目范围限定在可恢复负荷；
+
+　　第三，用动作证据替代口头计划。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　很多人会在过下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　别让短期体感绑架长期决策。
+## 四、为什么很多人“懂了”却还是卡住
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　这个时代变化很快，拒绝更新的人通常最先被动。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　先止损，再进攻，通常更稳。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　把这件事想透，你会少走很多弯路。
+
+　　当你把这笔账算清楚，很多焦虑会自动退潮。
+
+　　过最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 2 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\234\237\350\257\232\346\230\257\344\270\200\347\247\215\347\244\276\344\272\244\350\207\252\346\256\213.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\234\237\350\257\232\346\230\257\344\270\200\347\247\215\347\244\276\344\272\244\350\207\252\346\256\213.md"
new file mode 100644
index 00000000..05bd52b2
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\234\237\350\257\232\346\230\257\344\270\200\347\247\215\347\244\276\344\272\244\350\207\252\346\256\213.md"
@@ -0,0 +1,75 @@
+# 过度真诚是一种社交自残
+
+　　这不是观点输出，而是一次认知止损。
+
+　　说到底，这是一次“默认设置”的审计。
+
+　　先给结论：“过”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、这件事最常见的误读是什么
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　路径依赖一旦形成，后面每一步都像在给前一步打补丁。
+
+　　从策略上看，先止损，再进攻，通常比反过来更稳。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　这不是消极，而是对长期负责。
+## 三、从今天就能开始的三步动作
+
+　　先把输入源降噪，再谈深度输出。
+
+　　按这个顺序推进，阻力会小很多：
+
+　　第一，把作息边界改为低成本试错；
+
+　　第二，把承诺清单默认延迟非关键项；
+
+　　第三，用可重启替代一把梭哈。
+
+　　真正的安全感，不是计划写得漂亮，而是计划在现实里跑得动。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、你最容易忽略的边界条件
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　不要急着证明自己，先让流程稳定跑起来。
+## 五、最后回到最朴素的算术
+
+　　把这件事想透，你会少走很多弯路。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 11 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\244\274\350\262\214\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\260\210\345\210\244\345\270\255\344\275\215.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\244\274\350\262\214\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\260\210\345\210\244\345\270\255\344\275\215.md"
new file mode 100644
index 00000000..314c55a4
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\347\244\274\350\262\214\344\274\232\350\256\251\344\275\240\345\244\261\345\216\273\350\260\210\345\210\244\345\270\255\344\275\215.md"
@@ -0,0 +1,75 @@
+# 过度礼貌会让你失去谈判席位
+
+　　你会发现，真正拉开差距的从来不是狠劲，而是你有没有做长期结算。
+
+　　很多“我也知道”并不值钱，值钱的是能不能改动作。
+
+　　先给结论：“过”看起来像方法问题，底层其实是边界和代价的问题。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 三、先降摩擦，再提强度
+
+　　先把边界写清楚，再谈关系质量。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把作息边界设定触发即处理机制；
+
+　　第二，把作息边界改为低成本试错；
+
+　　第三，用小迭代替代大跃进。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　过最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+## 四、这一步不酷，但最值钱
+
+　　真正的分水岭，不在能力上限，而在纠偏速度。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　这一层补齐后，你会明显感觉阻力下降。
+## 五、把话说透：你要的是复利，不是爽感
+
+　　说到底，你要守住的不是“我看起来正确”，而是“我长期跑得动”。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　这一段看似不显眼，却往往决定了你后面是一条直线还是一圈回环。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 13 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\350\247\243\351\207\212\344\274\232\351\231\215\344\275\216\344\275\240\347\232\204\350\256\256\344\273\267\347\251\272\351\227\264.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\350\247\243\351\207\212\344\274\232\351\231\215\344\275\216\344\275\240\347\232\204\350\256\256\344\273\267\347\251\272\351\227\264.md"
new file mode 100644
index 00000000..866d7adf
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\345\272\246\350\247\243\351\207\212\344\274\232\351\231\215\344\275\216\344\275\240\347\232\204\350\256\256\344\273\267\347\251\272\351\227\264.md"
@@ -0,0 +1,75 @@
+# 过度解释会降低你的议价空间
+
+　　有些话听着刺耳，但它能直接落到现实里。
+
+　　关于“过度解释会降低你的议价空间”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：“过”这件事最反常识的地方是：短期舒服往往对应长期高成本。
+
+　　你现在的忙，真的和核心目标有关吗？
+
+## 一、表层很合理，底层很昂贵
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　看起来每天都在推进，实际上只是把同一种错误做得更熟练。
+
+　　很多所谓“天赋差距”，其实是“结算方式差距”。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、先建立闭环，再谈效率神话
+
+　　别先追求“做到极致”，先追求“做得到、做得稳、做得久”。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把复盘节点默认延迟非关键项；
+
+　　第二，把日程密度设定触发即处理机制；
+
+　　第三，用可持续替代高压。
+
+　　你先把它跑四周，再回头看，很多原来以为“无解”的地方会开始松动。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　把问题协议化，很多摩擦会提前消失。
+## 四、这一步不酷，但最值钱
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　比输更危险的是，把旧赢法当永久通行证。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　先做对，再做快，这几乎永远不会错。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　你不需要更狠，你需要更准。
+
+　　长期看，这是一条不花哨但非常值钱的路。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　所以过的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 10 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\346\227\251\345\256\232\345\236\213\344\274\232\351\231\220\345\210\266\344\275\240\347\232\204\346\210\230\347\225\245\345\274\271\346\200\247.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\346\227\251\345\256\232\345\236\213\344\274\232\351\231\220\345\210\266\344\275\240\347\232\204\346\210\230\347\225\245\345\274\271\346\200\247.md"
new file mode 100644
index 00000000..8de5dbfb
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\207\346\227\251\345\256\232\345\236\213\344\274\232\351\231\220\345\210\266\344\275\240\347\232\204\346\210\230\347\225\245\345\274\271\346\200\247.md"
@@ -0,0 +1,75 @@
+# 过早定型会限制你的战略弹性
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：多数人输在“过”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、第一步就错位，后面全是补丁
+
+　　这类误区最大的迷惑性在于：它和主流叙事高度一致。别人也这么干，所以你很难第一时间怀疑。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　很多人会在过下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、为什么很多人会陷入“越努力越挫败”
+
+　　很多人并不是不聪明，而是不愿意做一次痛苦但必要的重算。
+
+　　先删错误变量，正确变量才会冒头。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+
+　　当你愿意在过多花一点耐心，后面的很多冲突会自动降级。
+## 三、这件事落地，核心不在狠而在稳
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把输入渠道默认延迟非关键项；
+
+　　第二，把协作节奏减少到最小必要集；
+
+　　第三，用减法替代堆料。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+## 四、边界、止损与可重启能力
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、给这篇文章一个现实结尾
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　这不是励志，这是校准；校准之后，日子会轻很多。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 27 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\275\346\261\202\345\256\214\347\276\216\345\270\270\346\230\257\351\201\277\345\205\215\350\242\253\350\257\204\344\273\267\347\232\204\347\255\226\347\225\245.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\275\346\261\202\345\256\214\347\276\216\345\270\270\346\230\257\351\201\277\345\205\215\350\242\253\350\257\204\344\273\267\347\232\204\347\255\226\347\225\245.md"
new file mode 100644
index 00000000..ece3bab5
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\350\277\275\346\261\202\345\256\214\347\276\216\345\270\270\346\230\257\351\201\277\345\205\215\350\242\253\350\257\204\344\273\267\347\232\204\347\255\226\347\225\245.md"
@@ -0,0 +1,75 @@
+# 追求完美常是避免被评价的策略
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：多数人输在“追”上，不是因为不努力，而是因为把错误动作做得太熟练。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、先谈模型，不急着谈技巧
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　高压可以撑一阵，规则才能撑很多年。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 二、你以为躲开了风险，其实只是改了账期
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、这件事落地，核心不在狠而在稳
+
+　　如果要落地，我建议你先把复杂问题改写成可执行动作。动作可证据化，情绪就不会乱跑。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把复盘节点按优先级重排；
+
+　　第二，把消费冲动设置上限避免过载；
+
+　　第三，用规则替代临场猜测。
+
+　　动作一旦可重复，结果就会慢慢可预期。
+
+　　你真正要拿回来的，是选择权。
+
+　　放到现金流管理里，不留冗余缓冲，系统会在小波动里直接失衡。
+## 四、你最容易忽略的边界条件
+
+　　可迁移能力比短期头衔更保值。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　这不是消极，而是对长期负责。
+## 五、最后一句狠话：先做对，再做快
+
+　　把这件事想透，你会少走很多弯路。
+
+　　真正的升级不是突然开窍，而是持续纠偏。
+
+　　追最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　所以追的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 28 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\344\274\264\344\276\243\346\234\254\350\264\250\346\230\257\351\200\211\346\213\251\345\206\262\347\252\201\345\244\204\347\220\206\346\226\271\345\274\217.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\344\274\264\344\276\243\346\234\254\350\264\250\346\230\257\351\200\211\346\213\251\345\206\262\347\252\201\345\244\204\347\220\206\346\226\271\345\274\217.md"
new file mode 100644
index 00000000..5508f06d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\344\274\264\344\276\243\346\234\254\350\264\250\346\230\257\351\200\211\346\213\251\345\206\262\347\252\201\345\244\204\347\220\206\346\226\271\345\274\217.md"
@@ -0,0 +1,75 @@
+# 选择伴侣本质是选择冲突处理方式
+
+　　这个话题看着普通，但它决定的是你接下来几年会不会一直返工。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：在“选”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你是在管理风险，还是在转移风险？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　问题不在你不努力，而在你把努力投在了低回报接口上。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　它看起来像细节，实际上是决定系统能不能长期运行的关键接口。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、看起来没问题，为什么后面会突然失速
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　看清代价之后，很多执念会自己掉下去。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 三、别停在共鸣，直接落成流程
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把注意力减少到最小必要集；
+
+　　第二，把主目标加上结果验收标准；
+
+　　第三，用长期账替代短期爽。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、长期主义不是口号，是结算方式
+
+　　这一步看起来不酷，但最值钱。
+
+　　这条路不性感，但它稳定。稳定在今天就是稀缺资产。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　把这件事想透，你会少走很多弯路。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+
+　　当你愿意在选多花一点耐心，后面的很多冲突会自动降级。
+
+　　南国微雪 Miyuki
+
+　　2026 年 6 月 22 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\345\233\260\351\232\276\347\232\204\346\234\254\350\264\250\357\274\214\346\230\257\344\270\215\350\202\257\346\211\277\346\213\205\347\211\210\346\234\254\346\215\237\345\244\261.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\345\233\260\351\232\276\347\232\204\346\234\254\350\264\250\357\274\214\346\230\257\344\270\215\350\202\257\346\211\277\346\213\205\347\211\210\346\234\254\346\215\237\345\244\261.md"
new file mode 100644
index 00000000..eec3de40
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\200\211\346\213\251\345\233\260\351\232\276\347\232\204\346\234\254\350\264\250\357\274\214\346\230\257\344\270\215\350\202\257\346\211\277\346\213\205\347\211\210\346\234\254\346\215\237\345\244\261.md"
@@ -0,0 +1,75 @@
+# 选择困难的本质，是不肯承担版本损失
+
+　　我不想给你灌鸡汤，咱们只算现实账。账算清楚了，行动就会变得很干净。
+
+　　这件事真正难的，不是懂不懂，而是肯不肯重算。
+
+　　先给结论：在“选择困难的本质”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、你以为在优化，其实在放大偏差
+
+　　真正要拆的不是情绪，而是触发情绪的默认设置。
+
+　　把时间线拉到三年，你会发现差距不在天赋，而在系统。谁先把系统调顺，谁先拿到复利。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+
+　　这也是为什么我一直强调，先做对，再做快；顺序反了，代价很高。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　真正昂贵的不是犯错，而是长期不纠偏。拖得越久，修得越贵。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　只要不再重复同类错误，成长就会发生。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、如果要改，从这里开始最省成本
+
+　　先守住节律，再追求峰值表现。
+
+　　执行层面别贪多，先固定三条规则：
+
+　　第一，把作息边界只保留前三优先项；
+
+　　第二，把任务清单默认延迟非关键项；
+
+　　第三，用边界替代讨好。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、长期主义不是口号，是结算方式
+
+　　越想稳，越要学会阶段性止损。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　很多人会在是不肯承担版本损失下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　先止损，再进攻，通常更稳。
+
+　　长期看，决定差距的不是情绪强度，而是系统质量。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 24 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\225\277\346\234\237\344\270\273\344\271\211\346\234\200\345\215\261\351\231\251\347\232\204\350\257\257\347\224\250\357\274\214\346\230\257\347\273\231\346\213\226\345\273\266\345\274\200\347\273\277\347\201\257.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\225\277\346\234\237\344\270\273\344\271\211\346\234\200\345\215\261\351\231\251\347\232\204\350\257\257\347\224\250\357\274\214\346\230\257\347\273\231\346\213\226\345\273\266\345\274\200\347\273\277\347\201\257.md"
new file mode 100644
index 00000000..0bae103e
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\225\277\346\234\237\344\270\273\344\271\211\346\234\200\345\215\261\351\231\251\347\232\204\350\257\257\347\224\250\357\274\214\346\230\257\347\273\231\346\213\226\345\273\266\345\274\200\347\273\277\347\201\257.md"
@@ -0,0 +1,75 @@
+# 长期主义最危险的误用，是给拖延开绿灯
+
+　　多数人会在这类问题上反复摔跤，我也一样，所以我知道它有多隐蔽。
+
+　　我见过太多人在这个问题上绕圈：表面很拼，结果长期不动。
+
+　　先给结论：最该警惕的不是表面动作，而是动作背后那笔长期账。
+
+　　你守住的是结果，还是只是守住面子？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　很多“看起来很成熟”的选择，本质上只是把代价往后搬。短期体面，长期失血。
+
+　　你只要停掉几个低回报动作，节律就会明显变干净。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、你现在省下来的，会在未来怎么收费
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　你需要的不是再打一针鸡血，而是先停下来做一次系统审计。
+
+　　很多人会在长期主义最危险的误用下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　把这一层补齐，你会明显感觉到：同样的努力，产出开始变得可预测。
+## 三、先建立闭环，再谈效率神话
+
+　　先把任务做小到一周可验证，再谈宏大叙事。
+
+　　下面三条是低成本、可持续、可复盘的做法：
+
+　　第一，把项目范围写成明文规则；
+
+　　第二，把任务清单设定触发即处理机制；
+
+　　第三，用反馈闭环替代盲做。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　可恢复性比单次高光更关键。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　这一步做实，后面的动作才会开始有复利。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　真正的底气，不是永远不犯错，而是犯错后能快速回正。
+
+　　想通这个点，后面的很多决定都会更稳。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　所以长期主义最危险的误用的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+
+　　南国微雪 Miyuki
+
+　　2026 年 3 月 2 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\235\240\346\277\200\346\203\205\351\251\261\345\212\250\347\232\204\344\272\272\347\224\237\351\232\276\344\273\245\345\244\215\345\210\251.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\235\240\346\277\200\346\203\205\351\251\261\345\212\250\347\232\204\344\272\272\347\224\237\351\232\276\344\273\245\345\244\215\345\210\251.md"
new file mode 100644
index 00000000..2df2bb78
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\235\240\346\277\200\346\203\205\351\251\261\345\212\250\347\232\204\344\272\272\347\224\237\351\232\276\344\273\245\345\244\215\345\210\251.md"
@@ -0,0 +1,75 @@
+# 靠激情驱动的人生难以复利
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　越早把它拆到机制层，你越不容易被表面叙事骗。
+
+　　先给结论：如果你把“靠”当成纯粹意志力问题，后面大概率会陷入高消耗循环。
+
+　　你总说再等等，可窗口会不会先关上？
+
+## 一、为什么“看起来努力”经常导向“长期失速”
+
+　　我们很容易把“体感上的努力”误判成“结构上的进展”。前者给你情绪满足，后者才会给你结果。
+
+　　你今天的默认动作，基本就是你三年后的结果雏形。默认不改，结果很难改。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 二、长期账本里，什么才是大头
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这里真正该做的不是继续加码，而是先重算一次成本结构。
+
+　　所以靠的要点不是“再坚持”，而是“先校准”。校准之后，坚持才值钱。
+## 三、从今天就能开始的三步动作
+
+　　先做减法，再做加法，这个顺序几乎总是对的。
+
+　　如果你今天就想开始，先跑这三步：
+
+　　第一，把输出节奏放进固定复盘框架；
+
+　　第二，把协作节奏压到一周可验证；
+
+　　第三，用可重启替代一把梭哈。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　这不是理论洁癖，而是现实里的生存效率问题。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+## 四、稳定不是不变，而是持续适配
+
+　　你最该守住的，是长期可做而不是短期好看。
+
+　　真正成熟不是“我都懂”，而是“我愿意改”。
+
+　　真正危险的不是一次失误，而是失误被你日常化、合理化、最后制度化。
+
+　　这不是消极，而是对长期负责。
+
+　　放到决策上，不算机会成本，表面安全的选项往往最贵。
+## 五、最终结论：长期可做，比短期好看重要
+
+　　长期看，最值钱的是你保持清醒并持续行动的能力。
+
+　　赢一次不难，难的是别用一次赢法输掉后半生。
+
+　　靠最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 8 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\242\204\347\256\227\347\256\241\347\220\206\346\234\254\350\264\250\346\230\257\344\273\267\345\200\274\346\216\222\345\272\217\347\256\241\347\220\206.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\242\204\347\256\227\347\256\241\347\220\206\346\234\254\350\264\250\346\230\257\344\273\267\345\200\274\346\216\222\345\272\217\347\256\241\347\220\206.md"
new file mode 100644
index 00000000..438c419a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\242\204\347\256\227\347\256\241\347\220\206\346\234\254\350\264\250\346\230\257\344\273\267\345\200\274\346\216\222\345\272\217\347\256\241\347\220\206.md"
@@ -0,0 +1,75 @@
+# 预算管理本质是价值排序管理
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　关于“预算管理本质是价值排序管理”这件事，我更想讨论被大多数人自动忽略的那一层。
+
+　　先给结论：在“预”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　你有没有想过，你是在解决问题，还是在推迟问题？
+
+## 一、表层很合理，底层很昂贵
+
+　　看上去你是在优化，实际上你可能只是把原有偏差做得更稳定。偏差一稳定，就会变成天花板。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到人际关系里也一样，前面不把边界讲清楚，后面就容易靠情绪补窟窿。
+
+　　长期看，这一步带来的收益会远远超过它看上去的投入。
+## 二、长期账本里，什么才是大头
+
+　　这笔账里最贵的，不是钱，而是被悄悄抽走的选择权。
+
+　　这时候最危险的不是慢，而是盲目快。
+
+　　比起强撑，持续纠偏更能保命。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+## 三、从今天就能开始的三步动作
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　你可以先按这三步来，不复杂，但很硬：
+
+　　第一，把沟通窗口转成可追踪指标；
+
+　　第二，把承诺清单设定触发即处理机制；
+
+　　第三，用证据替代自责。
+
+　　你会发现，当流程稳定时，情绪也会跟着稳定。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+## 四、别把旧赢法当成永久通行证
+
+　　把旧赢法当永恒法则，是很多人后期掉队的直接原因。
+
+　　很多困局不是无解，只是还没换结算方式。
+
+　　你以为在省风险，很多时候只是在把风险推迟到更难处理的时候。
+
+　　与其继续加码，不如先把这层逻辑修正，这样后面的动作才有意义。
+
+　　放到长期规划里，不设止损条件，任何策略最后都可能变成执念。
+## 五、这件事真正的价值，在未来三年会体现
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　这一步如果偷懒，后面的每一步都要交学费，而且学费通常是叠加的。
+
+　　放到执行层面，任务颗粒度不够小，启动阻力就会持续偏高。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 11 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\346\225\210\345\267\245\345\205\267\347\224\250\351\224\231\344\272\206\344\274\232\345\217\230\346\210\220\346\263\250\346\204\217\345\212\233\345\261\240\345\244\253.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\346\225\210\345\267\245\345\205\267\347\224\250\351\224\231\344\272\206\344\274\232\345\217\230\346\210\220\346\263\250\346\204\217\345\212\233\345\261\240\345\244\253.md"
new file mode 100644
index 00000000..158f6f87
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\346\225\210\345\267\245\345\205\267\347\224\250\351\224\231\344\272\206\344\274\232\345\217\230\346\210\220\346\263\250\346\204\217\345\212\233\345\261\240\345\244\253.md"
@@ -0,0 +1,75 @@
+# 高效工具用错了会变成注意力屠夫
+
+　　先说一句不太好听的话：很多人的困局不是能力不够，而是长期在错误方向上用力。
+
+　　别把它当小问题，它会一点点吃掉你的选择权。
+
+　　先给结论：在“高”这个问题上，真正的分水岭是你怎么结算长期成本。
+
+　　如果旧方法已经过期，你还打算为它继续加码多久？
+
+## 一、先把错觉拆开：你到底在做什么
+
+　　如果你把这件事仅仅理解成“再坚持一下”，你后面大概率会进入一种高消耗循环。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多人会在高下意识地走老路，因为老路给人熟悉感，但熟悉感不等于正确率。
+
+　　放到自我管理上，不区分“重要”和“紧急”，注意力会被碎片任务吃光。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+## 二、真正昂贵的不是一次失误，而是持续误配
+
+　　它不是一次性爆炸，而是慢性失血。你以为只是最近状态差，其实底层已经超负荷运行。
+
+　　别急着把结果不理想都归因成“我不够好”。先查结构，再谈强度。
+
+　　如果你忽略了这层，后面大概率会出现“做了很多但没变好”的错觉。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　你不需要追求完美，只需要把这一步做到可重复，复利就会出现。
+## 三、先建立闭环，再谈效率神话
+
+　　先让流程能跑，再谈工具和技巧。工具只会放大已有结构。
+
+　　先把问题拆小，从这三步开始：
+
+　　第一，把沟通窗口减少到最小必要集；
+
+　　第二，把作息边界压到一周可验证；
+
+　　第三，用系统替代鸡血。
+
+　　先把流程跑顺，再谈效率神话。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　放到节律设计里，没有固定复盘点，人很容易在惯性里越走越偏。
+## 四、你最容易忽略的边界条件
+
+　　最后这道门槛，是你愿不愿意改旧脚本。很多人懂道理，但不愿动默认设置。
+
+　　别再迷信一次翻盘，成年人更依赖持续纠偏。
+
+　　多数人不是被大问题击倒，而是被一串小错配慢慢拖垮。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　这不是消极，而是对长期负责。
+## 五、如果只记住一句话，我希望是这个
+
+　　你要争取的不是一次高光，而是长期复利。
+
+　　路还是那条路，但你会明显感觉阻力变小。
+
+　　别让短期体感绑架长期决策。
+
+　　把问题协议化，很多摩擦会提前消失。
+
+　　这就是工程化思维的价值：不靠情绪爆发，靠稳定结构。
+
+　　南国微雪 Miyuki
+
+　　2026 年 4 月 14 日

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\350\264\250\351\207\217\347\213\254\345\244\204\344\270\215\346\230\257\351\200\203\351\201\277\357\274\214\350\200\214\346\230\257\347\263\273\347\273\237\347\273\264\346\212\244.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\350\264\250\351\207\217\347\213\254\345\244\204\344\270\215\346\230\257\351\200\203\351\201\277\357\274\214\350\200\214\346\230\257\347\263\273\347\273\237\347\273\264\346\212\244.md"
new file mode 100644
index 00000000..6aa2d46d
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\351\232\217\347\254\224\351\232\217\350\256\260/\350\215\211\347\250\277/\343\200\220\346\226\260\345\242\236\343\200\221\351\253\230\350\264\250\351\207\217\347\213\254\345\244\204\344\270\215\346\230\257\351\200\203\351\201\277\357\274\214\350\200\214\346\230\257\347\263\273\347\273\237\347\273\264\346\212\244.md"
@@ -0,0 +1,75 @@
+# 高质量独处不是逃避，而是系统维护
+
+　　这件事最可怕的是它常常伪装成“我在进步”。
+
+　　如果你把这题当成“性格题”，后面通常会很累。
+
+　　先给结论：关键不在逃避，而在系统维护。
+
+　　你是在主动选择，还是被默认路径推着走？
+
+## 一、先谈模型，不急着谈技巧
+
+　　多数人的第一层错误，是在错误地图上追求正确答案。答案再漂亮，也只是局部胜利。
+
+　　如果目标是长期稳定增长，就不能一直用短跑逻辑跑马拉松。
+
+　　很多所谓天赋差距，其实就是有人把这层做了，有人没做。
+
+　　放到学习里，不做输出验证，输入再多也很难沉淀成可用能力。
+
+　　把这个接口打通之后，很多“我做不到”会变成“我知道怎么做”。
+## 二、短期无感，长期高成本：这笔账怎么来的
+
+　　你当下省掉的不适，往往会在未来转成更重的返工、冲突和焦虑。
+
+　　这一步做对了，后面会省掉大量无意义拉扯。
+
+　　高质量独处不是逃避最反直觉的一点是：越是想快，越需要先把这一步做慢做实。
+
+　　拿生活里的场景说，今天看似省掉了十分钟，后面可能要用三小时返工。
+
+　　当你愿意在高质量独处不是逃避多花一点耐心，后面的很多冲突会自动降级。
+## 三、动作设计比情绪动员更关键
+
+　　先把系统摩擦降下来，再提强度。摩擦不降，强度越大越容易崩。
+
+　　把建议转成动作，至少先做到这三点：
+
+　　第一，把作息边界加入止损条件；
+
+　　第二，把输出节奏加入止损条件；
+
+　　第三，用清单替代情绪。
+
+　　先做对，再做快，这个顺序几乎总是更省命。
+
+　　当你开始按证据推进，焦虑会自然下降。
+
+　　放到工作里，你不做前置定义，团队最终一定会在协作环节反复扯皮。
+## 四、最后的门槛：你愿不愿意改旧脚本
+
+　　越想稳，越要学会阶段性止损。
+
+　　问题不是你不够好，而是系统没调到对的参数。
+
+　　系统健康，比一次高光重要得多。
+
+　　你会发现，真正稳定的人并不神秘，他们只是不会跳过这个环节。
+
+　　先止损，再进攻，通常更稳。
+## 五、到这里，应该能做一个更稳的决定了
+
+　　很多年后回头看，你会感谢今天这次诚实重算。
+
+　　把系统调顺之后，很多困难不会消失，但会变得可处理。
+
+　　你把这个点想透之后，会发现自己过去不少焦虑其实都来自错误定价。
+
+　　先把默认设置改掉，比再补一轮鸡血更有效。
+
+　　只要这层做实，系统会开始给你正反馈，焦虑感会自然下降。
+
+　　南国微雪 Miyuki
+
+　　2026 年 5 月 30 日