All Skills on Agent Skills Hub

微信读书笔记划线

Sun, 17 May 2026 00:00:00 +0000

notes — 笔记/划线

本文档区分两种口径：

统计口径：笔记数 = 书签数 + 划线数 + 想法/点评数。这里的"想法/点评"对应后端 reviewCount，包含划线想法、书评想法/个人点评、书摘、非书籍想法等个人内容。
内容导出口径：当前可导出的单本书笔记内容 = 划线内容 + 想法/点评内容。书签只在统计数量中体现，当前 /book/bookmarklist 已过滤书签，不能导出书签内容。

公开的他人点评不属于个人笔记，见 review.md。

接口

`/user/notebooks` — 笔记本概览（所有有笔记的书）

请求参数：

参数	类型	必填	说明
`count`	int	否	每页数量，默认 20
`lastSort`	int	否	翻页游标（上一页最后一条的 `sort` 值）

回包：

字段	说明
`totalBookCount`	有笔记的书籍总数
`totalNoteCount`	笔记总条数，统计口径为 `reviewCount + noteCount + bookmarkCount` 的汇总
`hasMore`	是否有更多（1=有）
`books[].bookId`	书籍 ID
`books[].book`	书籍信息（title, author, cover 等）
`books[].reviewCount`	想法/点评数：包含划线想法、书评想法/个人点评、书摘、非书籍想法等个人内容
`books[].noteCount`	划线数（高亮标注的原文条数）
`books[].bookmarkCount`	书签数（标记阅读位置的条数；只作为数量统计，当前不导出书签内容）
`books[].readingProgress`	阅读进度
`books[].markedStatus`	标记状态（1=读完, 0=在读）
`books[].sort`	排序值（最近笔记时间，用于翻页）

概念解释

用户问"有多少笔记"时，使用统计口径：reviewCount + noteCount + bookmarkCount。
noteCount 字段名容易误读：它不是单本书总笔记数，而是划线/高亮原文条数；单本书总笔记数必须自行计算。
/user/notebooks 不返回 highlightCount 字段；如果用户或上游说"高亮数/划线数"，对应字段是 noteCount。
reviewCount 已包含个人点评/书评想法，因此计算总笔记数时不要再额外加"点评数"，否则会重复计算。
/user/notebooks 概览无法把 reviewCount 拆成"划线想法"和"个人点评"的独立数量；如需内容明细，需继续查询 /review/list/mine。

分页规则

/user/notebooks 使用基于时间排序值的游标分页，不支持 offset/limit 分页。
第一次请求只传 count；如果 hasMore 为 1，取本页 books 最后一项的 sort，下一次作为 lastSort 传入。
所有业务参数必须平铺在 JSON body 顶层，和 api_name、skill_version 同级；不要包在 params 对象里。
不要传 offset、limit、start、size；这些参数不会被后端分页逻辑读取，可能导致重复第一页或结果不符合预期。
拉取完整列表时循环请求直到 hasMore 为 0，再按 reviewCount + noteCount + bookmarkCount 计算并降序排序。

`/book/bookmarklist` — 单本书的划线内容列表（不含书签内容）

自动过滤书签（type=0），只返回划线（type=1）。

微信读书书籍点评

Sun, 17 May 2026 00:00:00 +0000

review — 书籍点评

书籍的公开点评（区别于个人笔记/划线，个人笔记见 notes.md）。

接口

`/review/list` — 书籍公开点评

请求参数：

参数	类型	必填	说明
`bookId`	string	是	书籍 ID
`reviewListType`	int	否	筛选类型：0=全部, 1=推荐, 2=不行, 3=最新, 4=一般。默认 0
`count`	int	否	每页数量，默认 20
`maxIdx`	int	否	翻页偏移，默认 0
`synckey`	int	否	翻页游标，默认 0

回包（经裁剪）：

字段	说明
`synckey`	翻页游标（下次请求传入）
`reviewsCnt`	点评总数
`recentTotalCnt`	最新点评数
`reviewsHasMore`	是否有更多点评（1=有）
`reviewsHas5Star`	是否有五星推荐点评（1=有）
`reviewsHas1Star`	是否有一星差评（1=有）
`reviewsHasRecent`	是否有最新点评（1=有）
`friendCommentCount`	好友点评数
`friendUniqueCount`	点评好友数
`friendCommentUsers`	点评好友信息数组
`friendCommentUsers[].userVid`	好友 vid
`friendCommentUsers[].name`	好友昵称
`friendCommentUsers[].avatar`	好友头像
`deepVRecommendInfo`	资深会员推荐摘要
`deepVRecommendInfo.title`	如"2337 个资深会员点评"
`deepVRecommendInfo.subtitle`	如"其中 2015 人(86.2%)推荐本书"
`deepVRecommendValue`	资深会员推荐比例（862 = 86.2%）
`deepVUniqueCount`	点评资深会员数
`reviews`	点评数组
`reviews[].idx`	序号（用于翻页，下次 maxIdx 传最后一条的 idx）
`reviews[].review.reviewId`	点评唯一 ID
`reviews[].review.review.content`	点评文本内容
`reviews[].review.review.htmlContent`	点评 HTML 内容（富文本）
`reviews[].review.review.star`	评分（20=一星, 40=二星, 60=三星, 80=四星, 100=五星）
`reviews[].review.review.isFinish`	是否读完此书
`reviews[].review.review.createTime`	创建时间
`reviews[].review.review.chapterName`	所在章节名（章节点评时有值）
`reviews[].review.review.author.userVid`	评论者 vid
`reviews[].review.review.author.name`	评论者昵称
`reviews[].review.review.author.avatar`	评论者头像
`reviews[].review.review.book.bookId`	书籍 ID
`reviews[].review.review.book.title`	书名
`reviews[].review.review.book.author`	书籍作者

工作流

确定书籍：用户提供 bookId 直接使用，提供书名则先调 /store/search 获取 bookId。
调 /review/list 获取公开点评列表。
- 默认 reviewListType=0 看全部
- 用户要看推荐的传 reviewListType=1
- 用户要看最新的传 reviewListType=3
- 用户要看差评的传 reviewListType=2
- 用户要看一般的传 reviewListType=4
每条点评展示：评论者昵称、评分星级、点评内容（长内容截取摘要）。
翻页：用上一页最后一条的 idx 作为 maxIdx，带上 synckey。

输出格式

点评列表每条清晰分隔
评分转为星级展示（100=⭐⭐⭐⭐⭐，80=⭐⭐⭐⭐，60=⭐⭐⭐，40=⭐⭐，20=⭐）
长点评截取前 200 字，提示可展开

微信读书书籍信息

Sun, 17 May 2026 00:00:00 +0000

book — 书籍信息与阅读进度

查看书籍详情、章节目录、阅读进度。

接口

`/book/info` — 书籍基本信息

请求参数：

参数	类型	必填	说明
`bookId`	string	是	书籍 ID

回包：

字段	说明
`bookId`	书籍 ID
`title`	书名
`author`	作者
`translator`	译者
`cover`	封面 URL
`intro`	简介
`category`	分类
`publisher`	出版社
`publishTime`	出版时间
`isbn`	ISBN
`wordCount`	总字数
`newRating`	评分（百分制）
`newRatingCount`	评分人数
`newRatingDetail`	评分分布详情

`/book/chapterinfo` — 章节目录

请求参数：

参数	类型	必填	说明
`bookId`	string	是	书籍 ID

回包：

字段	说明
`bookId`	书籍 ID
`synckey`	同步 key（版本号）
`chapterUpdateTime`	章节最后更新时间
`chapters`	章节数组
`chapters[].chapterUid`	章节 UID（用于其他接口如 underlines）
`chapters[].chapterIdx`	章节序号
`chapters[].title`	章节标题
`chapters[].wordCount`	章节字数
`chapters[].level`	目录层级（1=一级标题, 2=二级…）
`chapters[].updateTime`	章节更新时间
`chapters[].price`	章节价格（0=免费）
`chapters[].paid`	是否已购买（1=已购买）
`chapters[].isMPChapter`	是否公众号章节（1=是）
`chapters[].anchors`	章节内锚点/子标题数组

`/book/getprogress` — 阅读进度

请求参数：

微信读书书架管理

Sun, 17 May 2026 00:00:00 +0000

shelf — 书架管理

重要概念

专辑 = 有声书，两者是同一概念。微信读书中，有声书/听书内容以"专辑"形式存在，存放在书架的 albums 字段中，与 books（电子书）完全独立。

书架里的"书"包含电子书和专辑/有声书。 当用户问"我的书架里有多少本书"“书架有多少本"“书架总数"时，不能只数 books[]，必须同时计入 albums[]。

常见错误：

⚠️ 不要通过遍历 books 逐个调 /book/info 检查 format 来判断有声书——/book/info 不返回 format 字段，且效率极低。直接使用 albums 字段即可。
⚠️ 书架数量必须用实际返回数组计算，且必须包含 albums[]；不要只用 books.length 回答"书架里有多少本书”。
⚠️ 公开/私密阅读数量也必须遍历实际返回条目，不能使用任何未出现在数组中的补丁项。

接口

/shelf/sync

请求参数： 无（用户身份通过 API Key 自动识别）

回包：

字段	说明
`books[]`	可枚举的电子书/导入书/公众号类书籍条目数组，不含 `albums[]`，也不含 `mp` 文章收藏入口
`books[].bookId`	书籍唯一标识
`books[].title`	书名
`books[].author`	作者
`books[].cover`	封面图 URL
`books[].category`	分类
`books[].readUpdateTime`	最近阅读时间（Unix 时间戳）
`books[].finishReading`	是否读完（1=读完）
`books[].updateTime`	书籍更新时间
`books[].isTop`	是否置顶
`books[].secret`	是否私密（1=私密）
`albums[]`	专辑/有声书数组（与 books 完全独立）
`albums[].albumInfo.albumId`	专辑唯一标识
`albums[].albumInfo.name`	专辑名称
`albums[].albumInfo.authorName`	演播/作者
`albums[].albumInfo.cover`	封面图 URL
`albums[].albumInfo.trackCount`	音频集数
`albums[].albumInfo.finishStatus`	完结状态（如"已完结”）
`albums[].albumInfo.finish`	是否完结（1=完结）
`albums[].albumInfo.payType`	付费类型
`albums[].albumInfo.intro`	专辑简介
`albums[].albumInfo.updateTime`	更新时间（Unix 时间戳）
`albums[].albumInfoExtra.secret`	是否私密
`albums[].albumInfoExtra.lecturePaid`	是否已购买（1=已购买）
`albums[].albumInfoExtra.lectureReadUpdateTime`	最近收听时间
`albums[].albumInfoExtra.isTop`	是否置顶
`mp`	文章收藏入口对象；只表示"文章收藏"目录入口，不包含具体文章内容；非空时表示书架界面有 1 个"文章收藏"条目，不包含在 `books[]`/`albums[]` 中
`archive[].name`	书单名称
`archive[].bookIds`	书单内的 bookId 列表
`bookCount`	可枚举电子书数量，通常等于 `books[].length`；不含 `albums[]` 和 `mp`

数量口径

用户问题/指标	正确计算方式	说明
书架界面有多少本/多少条目	`books.length + albums.length + (mp 非空 ? 1 : 0)`	默认回答这个口径；用户说"书架里的书"时也包含专辑/有声书
电子书数	`bookCount` 或 `books.length`	仅 `books[]`，不含专辑和文章收藏；只有用户明确问"电子书"时才用这个口径
有声书/专辑数	`albums.length`	专辑按有声书管理，也是书架总数的一部分
是否有文章收藏	`mp 非空 ? 1 : 0`	`mp` 是单独入口，但其中不包含文章收藏的具体内容

⚠️ 强制回答规则：当用户问任何书架数量问题时，必须使用实际可枚举数组计算：books.length + albums.length + (mp 非空 ? 1 : 0)。其中 albums.length 必须计入，因为专辑/有声书在书架里也按"书"管理。不要使用其他服务端内部计数字段或基于内部计数字段的公式。

微信读书搜索

Sun, 17 May 2026 00:00:00 +0000

search — 搜索

支持多种搜索类型，通过 scope 参数切换 tab，来指定不同的搜索结果 tab 页面。

接口

/store/search

请求参数：

参数	类型	必填	说明
`keyword`	string	是	搜索关键词
`scope`	int	否	搜索类型。Agent 应按下方"scope 选择指引"显式选择；未传时服务端默认 10（电子书）
`maxIdx`	int	否	翻页偏移，默认 0
`count`	int	否	每页数量，不传则服务端默认 15。用户未指定数量时不要传此参数

scope 对应关系：

scope	名称	说明
`0`	全部	综合搜索，results 中包含多个分组；适合用户只说"搜一下"且未限定类型
`10`	电子书	只搜电子书（不含网文小说）；适合用户明确"搜书/找书/搜某本书"
`16`	网文小说	只搜网文小说
`14`	微信听书	有声书/专辑/播客（三者同义）
`6`	作者	搜索作者
`12`	全文	搜索书籍正文内容
`13`	书单	搜索书单
`2`	公众号	搜索公众号
`4`	文章	搜索公众号文章

scope 选择指引（Agent 根据用户意图自动选择）：

微信读书推荐

Sun, 17 May 2026 00:00:00 +0000

discover — 发现推荐好书

接口

`/book/recommend` — 个性化推荐（为你推荐）

基于用户阅读记录的个性化推荐，与 App 首页「为你推荐」一致。

请求参数：

参数	类型	必填	说明
`count`	int	否	每页数量，默认 12
`maxIdx`	int	否	翻页偏移，默认 0

回包：

字段	说明
`books`	推荐书籍数组
`books[].bookId`	书籍 ID
`books[].title`	书名
`books[].author`	作者
`books[].cover`	封面图 URL
`books[].intro`	简介
`books[].category`	分类
`books[].reason`	推荐理由
`books[].readingCount`	在读人数
`books[].searchIdx`	结果序号（用于翻页）
`books[].newRating`	评分（0-100）
`books[].newRatingCount`	评分人数
`books[].newRatingDetail.title`	评分标签（如"神作"“力荐”）
`books[].price`	价格（分）
`books[].payType`	付费类型
`books[].type`	书籍类型（0=电子书）

`/book/similar` — 相似书推荐

基于某本书推荐相似书籍，与 App 书籍详情页「相似推荐」一致。

请求参数：

参数	类型	必填	说明
`bookId`	string	是	书籍 ID
`count`	int	否	每页数量，默认 12
`maxIdx`	int	否	翻页偏移，默认 0
`sessionId`	string	否	翻页会话 ID（首次不传，后续传回包中的值）

回包：

微信读书用户信息

Sun, 17 May 2026 00:00:00 +0000

profile — 用户信息与阅读统计

说明

通过组合已有接口获取用户阅读概况。

工作流

1. 获取书架

调 /shelf/sync，了解用户在读什么书、总数等。书架数量必须按 books.length + albums.length + (mp 非空 ? 1 : 0) 计算；albums[] 是专辑/有声书，也属于书架里的书，不能只统计 books[]。具体逻辑参考 shelf.md。

2. 获取阅读进度

对书架中的书调 /book/getprogress，获取进度和阅读时长，具体见book.md

3. 获取笔记

调 /book/bookmarklist，获取划线数量，具体见notes.md

输出格式

综合书架和阅读进度信息，展示用户阅读概况
每本书显示：书名、进度、最近阅读时间
无参数时展示阅读概况（书架 + 最近阅读进度）

微信读书阅读统计

Sun, 17 May 2026 00:00:00 +0000

readdata — 阅读统计

查看个人阅读数据统计，包含阅读时长、天数、读书排行、偏好分析等。

⚠️ 使用前必须阅读本文件字段说明。 阅读统计字段容易因字段名产生误判，尤其是所有阅读时长字段的单位。调用 /readdata/detail 前必须先确认本文件中的参数、字段单位和统计口径；禁止凭字段名或数值大小推断单位。

接口

`/readdata/detail` — 阅读统计详情

请求参数：

参数	类型	必填	说明
`mode`	string	否	统计维度：`weekly`=本周, `monthly`=本月, `annually`=本年, `overall`=总计。默认 `monthly`。
`baseTime`	int	否	基准时间戳（0=当前周期），此时服务端会归一化到周期起点：周一、月初、年初；`overall` 固定为 0。传历史时间戳可查看该时间戳所在周期的数据；`annually` 只返回 `baseTime` 所在自然年的数据，不会自动包含后续年份

回包字段说明（字段按 mode 和数据条件可选返回）：

字段	说明
`baseTime`	统计周期的基准时间戳：`weekly` 为周一 00:00，`monthly` 为月初 00:00，`annually` 为年初 00:00，`overall` 为 0
`readTimes`	分桶阅读/收听总时长（对象，key 为分桶起始时间戳，value 为秒数）。`weekly`/`monthly` 通常按天分桶，`annually` 按月分桶，`overall` 按年分桶
`dailyReadTimes`	年度模式可能返回的每日阅读时长明细（对象，key 为日期时间戳，value 为秒数）；用于日历明细展示，不应替代 `totalReadTime` 作为总量口径
`readDays`	有效阅读天数。服务端按有效阅读规则计算，当前规则为单日阅读满 1 分钟
`totalReadTime`	当前请求周期的总阅读/收听时长（秒）。统计总时长时优先使用该字段，`readTimes` 仅用于明细展示或交叉校验；禁止误当成分钟或小时
`dayAverageReadTime`	日均阅读/收听时长（秒），分母是当前周期已过去的自然日数或历史完整周期自然日数，不是 `readDays`
`compare`	与上一周期的日均时长对比比例；正数表示增长，负数表示下降。该字段只在当前周期且上一周期数据足够时返回，`0.2` 表示约增长 20%
`readLongest`	读得最多的书/有声内容排行数组，最多 10 条，按 `readTime` 降序；低于 5 分钟的条目会被过滤
`readLongest[].book`	书籍信息对象（电子书/出版书），包含 `bookId`、`title`、`author`、`cover` 等
`readLongest[].albumInfo`	有声内容信息对象；当排行条目是有声书/专辑时返回
`readLongest[].readTime`	该书或有声内容在当前统计范围内的阅读/收听时长（秒）
`readLongest[].recordReadingTime`	该书的朗读/记录类阅读时长（秒），存在时才返回
`readLongest[].tags`	标签数组，目前常见值包括 `笔记最多`、`单日阅读最久`
`readStat`	阅读统计摘要数组
`readStat[].stat`	统计项名称，常见为 `读过`、`读完`、`阅读`、`笔记`
`readStat[].counts`	统计值文案，如 `12本`、`45天`、`120条`
`readStat[].scheme`	对应统计项的 App 跳转链接，可能为空
`preferCategory`	偏好阅读分类数组，最多 8 个；不足时可能补充默认分类占位
`preferCategory[].categoryId`	分类 ID
`preferCategory[].categoryTitle`	分类名称
`preferCategory[].parentCategoryId`	父分类 ID
`preferCategory[].parentCategoryTitle`	父分类名称
`preferCategory[].val`	分类偏好权重，按最高分类阅读时长归一化后的相对值，用于图表展示
`preferCategory[].readingTime`	该分类阅读时长（秒）
`preferCategory[].readingCount`	该分类阅读本数
`preferCategory[].categoryType`	分类类型标记，普通分类为 0，部分特殊分类会返回 1 或 2
`preferCategoryWord`	偏好分类文案，如 `偏好阅读文学`；年度报告场景可能改为固定文案 `偏好阅读`
`preferTime`	24 小时阅读时段分布数组，值为秒数。注意输出顺序从 6 点开始，依次到次日 5 点，不是从 0 点开始
`preferTimeWord`	偏好时段文案。总偏好时段数据不足 10 小时时可能不返回；常见文案如 `偏好上午阅读`、`偏好白天阅读`、`偏好夜间阅读`、`汲取新知，昼夜不倦`
`preferAuthor`	偏好作者数组。只有作者数据达到展示阈值时返回
`preferAuthor[].authorId`	作者 ID
`preferAuthor[].name`	作者名
`preferAuthor[].count`	阅读该作者的书本数
`preferAuthor[].readTime`	阅读该作者作品的时长，格式化字符串，如 `5小时30分钟`，不是秒数
`preferAuthor[].user`	作者关联用户信息，存在时返回
`authorCount`	符合统计条件的作者总数，不一定等于 `preferAuthor` 返回条数
`preferPublisher`	偏好出版社数组。至少 3 个出版社且最高出版社阅读本数达到阈值时返回
`preferPublisher[].name`	出版社名
`preferPublisher[].count`	阅读该出版社书籍的本数
`preferCp`	偏好版权方数组。满足展示阈值时返回
`preferCp[].count`	阅读该版权方书籍的本数
`preferCp[].copyrightInfo`	版权方信息，包括名称、用户 VID、头像、角色等
`readRate`	文字阅读占比百分比，计算口径约为 `wrReadTime / (wrReadTime + wrListenTime) * 100`。当总时长不足 1 小时或文字阅读占比过高时不返回
`wrReadTime`	文字阅读时长（秒），通常为 `totalReadTime - wrListenTime`；仅在 `readRate` 可展示时返回
`wrListenTime`	听书/TTS/有声内容时长（秒）；仅在 `readRate` 可展示时返回
`rank`	本周好友阅读排行信息；仅当前周且未隐藏排行时返回
`rank.text`	排行文案，如 `朋友中排第3名`
`rank.scheme`	排行跳转链接
`registTime`	用户注册时间戳
`medals`	勋章数组；可展示勋章不少于 3 个时返回
`preferBooks`	偏好阅读书籍卡片数组，包含书籍、推荐理由和偏好类型等信息
`yearReport`	年度报告入口数组。`overall` 可能返回多年的入口，`annually` 可能返回当前年份入口；`times` 为该年 12 个月阅读/收听时长数组
`recordReadingTime`	总朗读/记录类阅读时长（秒），目前主要在 `overall` 模式下汇总返回
`readRecordsWord`	书籍分布模块标题文案，当前固定为 `书籍分布`
`readDistributionWord`	点评分布模块标题文案，当前固定为 `点评分布`
`readTimeGears`	阅读时长档位数组，当前为 `[60, 1800, 3600, 10800, 18000]`，用于前端展示分段
`styleType`	样式类型，常见为 `normal`；年度报告场景可能返回特殊样式

年度报告相关字段（如 annualList2023、preferBooks2023、2025 年报模块字段等）会随活动配置变化，不作为通用阅读统计字段依赖。

Agent Builder

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

Agent Builder

Build AI agents for any domain - customer service, research, operations, creative work, or specialized business processes.

The Core Philosophy

The model already knows how to be an agent. Your job is to get out of the way.

An agent is not complex engineering. It’s a simple loop that invites the model to act:

LOOP:
 Model sees: context + available capabilities
 Model decides: act or respond
 If act: execute capability, add result, continue
 If respond: return to user

That’s it. The magic isn’t in the code - it’s in the model. Your code just provides the opportunity.

Agent Memory

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

Agent Memory

A persistent memory space for storing knowledge that survives across conversations.

Location: .claude/skills/agent-memory/memories/

Proactive Usage

Save memories when you discover something worth preserving:

Research findings that took effort to uncover
Non-obvious patterns or gotchas in the codebase
Solutions to tricky problems
Architectural decisions and their rationale
In-progress work that may be resumed later

Check memories when starting related work:

Before investigating a problem area
When working on a feature you’ve touched before
When resuming work after a conversation break

Organize memories when needed:

Agent Review

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

Agent Review

Get feedback from an external AI agent. Useful for code review, architecture decisions, or getting a second opinion.

Running Commands

1echo "code or prompt" | node .claude/skills/agent-review/query.mjs [options] "Your question"
2# or
3node .claude/skills/agent-review/query.mjs --file <path> [options] "Your question"

Options

Flag	Short	Description
`--model <model>`	`-m`	Model or alias (default: gemini)
`--file <path>`	`-f`	Read input from file instead of stdin
`--lines <start-end>`	`-l`	Extract specific lines from file (e.g., 50-100)
`--context <path>`	`-c`	Additional context file (can repeat)
`--system <prompt>`	`-s`	Custom system prompt
`--temperature <n>`	`-t`	Temperature 0-1 (default: 0.7)
`--quiet`	`-q`	Suppress status messages and usage stats
`--list`		List available models
`--json`		Output raw JSON response

Available Models

Model ID	Aliases	Provider	Notes
`google/gemini-3-pro-preview`	`gemini`, `g3`	OpenRouter	Default - good for external perspective
`openai/gpt-5.1-codex`	`gpt`, `codex`, `gpt5`	OpenRouter	Strong at code analysis
`anthropic/claude-opus-4.5`	`opus`, `claude-opus`	Agent SDK	Uses local subscription
`anthropic/claude-sonnet-4.5`	`sonnet`, `claude`	Agent SDK	Uses local subscription

Anthropic models route through Claude Agent SDK (uses your Claude subscription). Other models route through OpenRouter API (requires OPENROUTER_API_KEY).

Agile Product Owner

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

Agile Product Owner

Complete toolkit for Product Owners to excel at backlog management and sprint execution.

Core Capabilities

INVEST-compliant user story generation
Automatic acceptance criteria creation
Sprint capacity planning
Backlog prioritization
Velocity tracking and metrics

Key Scripts

user_story_generator.py

Generates well-formed user stories with acceptance criteria from epics.

Usage:

Generate stories: python scripts/user_story_generator.py
Plan sprint: python scripts/user_story_generator.py sprint [capacity]

Features:

Breaks epics into stories
INVEST criteria validation
Automatic point estimation
Priority assignment
Sprint planning with capacity

Airflow Dag Patterns

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

Apache Airflow DAG Patterns

Production-ready patterns for Apache Airflow including DAG design, operators, sensors, testing, and deployment strategies.

When to Use This Skill

Creating data pipeline orchestration with Airflow
Designing DAG structures and dependencies
Implementing custom operators and sensors
Testing Airflow DAGs locally
Setting up Airflow in production
Debugging failed DAG runs

Core Concepts

1. DAG Design Principles

Principle	Description
Idempotent	Running twice produces same result
Atomic	Tasks succeed or fail completely
Incremental	Process only new/changed data
Observable	Logs, metrics, alerts at every step

2. Task Dependencies

 1# Linear
 2task1 >> task2 >> task3
 3
 4# Fan-out
 5task1 >> [task2, task3, task4]
 6
 7# Fan-in
 8[task1, task2, task3] >> task4
 9
10# Complex
11task1 >> task2 >> task4
12task1 >> task3 >> task4

Quick Start

 1# dags/example_dag.py
 2from datetime import datetime, timedelta
 3from airflow import DAG
 4from airflow.operators.python import PythonOperator
 5from airflow.operators.empty import EmptyOperator
 6
 7default_args = {
 8 'owner': 'data-team',
 9 'depends_on_past': False,
10 'email_on_failure': True,
11 'email_on_retry': False,
12 'retries': 3,
13 'retry_delay': timedelta(minutes=5),
14 'retry_exponential_backoff': True,
15 'max_retry_delay': timedelta(hours=1),
16}
17
18with DAG(
19 dag_id='example_etl',
20 default_args=default_args,
21 description='Example ETL pipeline',
22 schedule='0 6 * * *', # Daily at 6 AM
23 start_date=datetime(2024, 1, 1),
24 catchup=False,
25 tags=['etl', 'example'],
26 max_active_runs=1,
27) as dag:
28
29 start = EmptyOperator(task_id='start')
30
31 def extract_data(**context):
32 execution_date = context['ds']
33 # Extract logic here
34 return {'records': 1000}
35
36 extract = PythonOperator(
37 task_id='extract',
38 python_callable=extract_data,
39 )
40
41 end = EmptyOperator(task_id='end')
42
43 start >> extract >> end

Patterns

Pattern 1: TaskFlow API (Airflow 2.0+)

 1# dags/taskflow_example.py
 2from datetime import datetime
 3from airflow.decorators import dag, task
 4from airflow.models import Variable
 5
 6@dag(
 7 dag_id='taskflow_etl',
 8 schedule='@daily',
 9 start_date=datetime(2024, 1, 1),
10 catchup=False,
11 tags=['etl', 'taskflow'],
12)
13def taskflow_etl():
14 """ETL pipeline using TaskFlow API"""
15
16 @task()
17 def extract(source: str) -> dict:
18 """Extract data from source"""
19 import pandas as pd
20
21 df = pd.read_csv(f's3://bucket/{source}/{{ ds }}.csv')
22 return {'data': df.to_dict(), 'rows': len(df)}
23
24 @task()
25 def transform(extracted: dict) -> dict:
26 """Transform extracted data"""
27 import pandas as pd
28
29 df = pd.DataFrame(extracted['data'])
30 df['processed_at'] = datetime.now()
31 df = df.dropna()
32 return {'data': df.to_dict(), 'rows': len(df)}
33
34 @task()
35 def load(transformed: dict, target: str):
36 """Load data to target"""
37 import pandas as pd
38
39 df = pd.DataFrame(transformed['data'])
40 df.to_parquet(f's3://bucket/{target}/{{ ds }}.parquet')
41 return transformed['rows']
42
43 @task()
44 def notify(rows_loaded: int):
45 """Send notification"""
46 print(f'Loaded {rows_loaded} rows')
47
48 # Define dependencies with XCom passing
49 extracted = extract(source='raw_data')
50 transformed = transform(extracted)
51 loaded = load(transformed, target='processed_data')
52 notify(loaded)
53
54# Instantiate the DAG
55taskflow_etl()

Pattern 2: Dynamic DAG Generation

 1# dags/dynamic_dag_factory.py
 2from datetime import datetime, timedelta
 3from airflow import DAG
 4from airflow.operators.python import PythonOperator
 5from airflow.models import Variable
 6import json
 7
 8# Configuration for multiple similar pipelines
 9PIPELINE_CONFIGS = [
10 {'name': 'customers', 'schedule': '@daily', 'source': 's3://raw/customers'},
11 {'name': 'orders', 'schedule': '@hourly', 'source': 's3://raw/orders'},
12 {'name': 'products', 'schedule': '@weekly', 'source': 's3://raw/products'},
13]
14
15def create_dag(config: dict) -> DAG:
16 """Factory function to create DAGs from config"""
17
18 dag_id = f"etl_{config['name']}"
19
20 default_args = {
21 'owner': 'data-team',
22 'retries': 3,
23 'retry_delay': timedelta(minutes=5),
24 }
25
26 dag = DAG(
27 dag_id=dag_id,
28 default_args=default_args,
29 schedule=config['schedule'],
30 start_date=datetime(2024, 1, 1),
31 catchup=False,
32 tags=['etl', 'dynamic', config['name']],
33 )
34
35 with dag:
36 def extract_fn(source, **context):
37 print(f"Extracting from {source} for {context['ds']}")
38
39 def transform_fn(**context):
40 print(f"Transforming data for {context['ds']}")
41
42 def load_fn(table_name, **context):
43 print(f"Loading to {table_name} for {context['ds']}")
44
45 extract = PythonOperator(
46 task_id='extract',
47 python_callable=extract_fn,
48 op_kwargs={'source': config['source']},
49 )
50
51 transform = PythonOperator(
52 task_id='transform',
53 python_callable=transform_fn,
54 )
55
56 load = PythonOperator(
57 task_id='load',
58 python_callable=load_fn,
59 op_kwargs={'table_name': config['name']},
60 )
61
62 extract >> transform >> load
63
64 return dag
65
66# Generate DAGs
67for config in PIPELINE_CONFIGS:
68 globals()[f"dag_{config['name']}"] = create_dag(config)

Pattern 3: Branching and Conditional Logic

 1# dags/branching_example.py
 2from airflow.decorators import dag, task
 3from airflow.operators.python import BranchPythonOperator
 4from airflow.operators.empty import EmptyOperator
 5from airflow.utils.trigger_rule import TriggerRule
 6
 7@dag(
 8 dag_id='branching_pipeline',
 9 schedule='@daily',
10 start_date=datetime(2024, 1, 1),
11 catchup=False,
12)
13def branching_pipeline():
14
15 @task()
16 def check_data_quality() -> dict:
17 """Check data quality and return metrics"""
18 quality_score = 0.95 # Simulated
19 return {'score': quality_score, 'rows': 10000}
20
21 def choose_branch(**context) -> str:
22 """Determine which branch to execute"""
23 ti = context['ti']
24 metrics = ti.xcom_pull(task_ids='check_data_quality')
25
26 if metrics['score'] >= 0.9:
27 return 'high_quality_path'
28 elif metrics['score'] >= 0.7:
29 return 'medium_quality_path'
30 else:
31 return 'low_quality_path'
32
33 quality_check = check_data_quality()
34
35 branch = BranchPythonOperator(
36 task_id='branch',
37 python_callable=choose_branch,
38 )
39
40 high_quality = EmptyOperator(task_id='high_quality_path')
41 medium_quality = EmptyOperator(task_id='medium_quality_path')
42 low_quality = EmptyOperator(task_id='low_quality_path')
43
44 # Join point - runs after any branch completes
45 join = EmptyOperator(
46 task_id='join',
47 trigger_rule=TriggerRule.NONE_FAILED_MIN_ONE_SUCCESS,
48 )
49
50 quality_check >> branch >> [high_quality, medium_quality, low_quality] >> join
51
52branching_pipeline()

Pattern 4: Sensors and External Dependencies

 1# dags/sensor_patterns.py
 2from datetime import datetime, timedelta
 3from airflow import DAG
 4from airflow.sensors.filesystem import FileSensor
 5from airflow.providers.amazon.aws.sensors.s3 import S3KeySensor
 6from airflow.sensors.external_task import ExternalTaskSensor
 7from airflow.operators.python import PythonOperator
 8
 9with DAG(
10 dag_id='sensor_example',
11 schedule='@daily',
12 start_date=datetime(2024, 1, 1),
13 catchup=False,
14) as dag:
15
16 # Wait for file on S3
17 wait_for_file = S3KeySensor(
18 task_id='wait_for_s3_file',
19 bucket_name='data-lake',
20 bucket_key='raw/{{ ds }}/data.parquet',
21 aws_conn_id='aws_default',
22 timeout=60 * 60 * 2, # 2 hours
23 poke_interval=60 * 5, # Check every 5 minutes
24 mode='reschedule', # Free up worker slot while waiting
25 )
26
27 # Wait for another DAG to complete
28 wait_for_upstream = ExternalTaskSensor(
29 task_id='wait_for_upstream_dag',
30 external_dag_id='upstream_etl',
31 external_task_id='final_task',
32 execution_date_fn=lambda dt: dt, # Same execution date
33 timeout=60 * 60 * 3,
34 mode='reschedule',
35 )
36
37 # Custom sensor using @task.sensor decorator
38 @task.sensor(poke_interval=60, timeout=3600, mode='reschedule')
39 def wait_for_api() -> PokeReturnValue:
40 """Custom sensor for API availability"""
41 import requests
42
43 response = requests.get('https://api.example.com/health')
44 is_done = response.status_code == 200
45
46 return PokeReturnValue(is_done=is_done, xcom_value=response.json())
47
48 api_ready = wait_for_api()
49
50 def process_data(**context):
51 api_result = context['ti'].xcom_pull(task_ids='wait_for_api')
52 print(f"API returned: {api_result}")
53
54 process = PythonOperator(
55 task_id='process',
56 python_callable=process_data,
57 )
58
59 [wait_for_file, wait_for_upstream, api_ready] >> process

Pattern 5: Error Handling and Alerts

 1# dags/error_handling.py
 2from datetime import datetime, timedelta
 3from airflow import DAG
 4from airflow.operators.python import PythonOperator
 5from airflow.utils.trigger_rule import TriggerRule
 6from airflow.models import Variable
 7
 8def task_failure_callback(context):
 9 """Callback on task failure"""
10 task_instance = context['task_instance']
11 exception = context.get('exception')
12
13 # Send to Slack/PagerDuty/etc
14 message = f"""
15 Task Failed!
16 DAG: {task_instance.dag_id}
17 Task: {task_instance.task_id}
18 Execution Date: {context['ds']}
19 Error: {exception}
20 Log URL: {task_instance.log_url}
21 """
22 # send_slack_alert(message)
23 print(message)
24
25def dag_failure_callback(context):
26 """Callback on DAG failure"""
27 # Aggregate failures, send summary
28 pass
29
30with DAG(
31 dag_id='error_handling_example',
32 schedule='@daily',
33 start_date=datetime(2024, 1, 1),
34 catchup=False,
35 on_failure_callback=dag_failure_callback,
36 default_args={
37 'on_failure_callback': task_failure_callback,
38 'retries': 3,
39 'retry_delay': timedelta(minutes=5),
40 },
41) as dag:
42
43 def might_fail(**context):
44 import random
45 if random.random() < 0.3:
46 raise ValueError("Random failure!")
47 return "Success"
48
49 risky_task = PythonOperator(
50 task_id='risky_task',
51 python_callable=might_fail,
52 )
53
54 def cleanup(**context):
55 """Cleanup runs regardless of upstream failures"""
56 print("Cleaning up...")
57
58 cleanup_task = PythonOperator(
59 task_id='cleanup',
60 python_callable=cleanup,
61 trigger_rule=TriggerRule.ALL_DONE, # Run even if upstream fails
62 )
63
64 def notify_success(**context):
65 """Only runs if all upstream succeeded"""
66 print("All tasks succeeded!")
67
68 success_notification = PythonOperator(
69 task_id='notify_success',
70 python_callable=notify_success,
71 trigger_rule=TriggerRule.ALL_SUCCESS,
72 )
73
74 risky_task >> [cleanup_task, success_notification]

Pattern 6: Testing DAGs

 1# tests/test_dags.py
 2import pytest
 3from datetime import datetime
 4from airflow.models import DagBag
 5
 6@pytest.fixture
 7def dagbag():
 8 return DagBag(dag_folder='dags/', include_examples=False)
 9
10def test_dag_loaded(dagbag):
11 """Test that all DAGs load without errors"""
12 assert len(dagbag.import_errors) == 0, f"DAG import errors: {dagbag.import_errors}"
13
14def test_dag_structure(dagbag):
15 """Test specific DAG structure"""
16 dag = dagbag.get_dag('example_etl')
17
18 assert dag is not None
19 assert len(dag.tasks) == 3
20 assert dag.schedule_interval == '0 6 * * *'
21
22def test_task_dependencies(dagbag):
23 """Test task dependencies are correct"""
24 dag = dagbag.get_dag('example_etl')
25
26 extract_task = dag.get_task('extract')
27 assert 'start' in [t.task_id for t in extract_task.upstream_list]
28 assert 'end' in [t.task_id for t in extract_task.downstream_list]
29
30def test_dag_integrity(dagbag):
31 """Test DAG has no cycles and is valid"""
32 for dag_id, dag in dagbag.dags.items():
33 assert dag.test_cycle() is None, f"Cycle detected in {dag_id}"
34
35# Test individual task logic
36def test_extract_function():
37 """Unit test for extract function"""
38 from dags.example_dag import extract_data
39
40 result = extract_data(ds='2024-01-01')
41 assert 'records' in result
42 assert isinstance(result['records'], int)

Project Structure

airflow/
├── dags/
│ ├── __init__.py
│ ├── common/
│ │ ├── __init__.py
│ │ ├── operators.py # Custom operators
│ │ ├── sensors.py # Custom sensors
│ │ └── callbacks.py # Alert callbacks
│ ├── etl/
│ │ ├── customers.py
│ │ └── orders.py
│ └── ml/
│ └── training.py
├── plugins/
│ └── custom_plugin.py
├── tests/
│ ├── __init__.py
│ ├── test_dags.py
│ └── test_operators.py
├── docker-compose.yml
└── requirements.txt

Best Practices

Do’s

Use TaskFlow API - Cleaner code, automatic XCom
Set timeouts - Prevent zombie tasks
Use mode='reschedule' - For sensors, free up workers
Test DAGs - Unit tests and integration tests
Idempotent tasks - Safe to retry

Don’ts

Don’t use depends_on_past=True - Creates bottlenecks
Don’t hardcode dates - Use {{ ds }} macros
Don’t use global state - Tasks should be stateless
Don’t skip catchup blindly - Understand implications
Don’t put heavy logic in DAG file - Import from modules

Resources

Angular Modernization

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

Angular Modernization

Transforms legacy Angular components to modern architecture using a two-step approach:

Automated migrations - Angular CLI schematics for standalone, control flow, and signals
Bitwarden patterns - ADR compliance, OnPush change detection, proper visibility, thin components

Workflow

Step 1: Run Angular CLI Migrations

⚠️ CRITICAL: ALWAYS use Angular CLI migrations when available. DO NOT manually migrate features that have CLI schematics.

Angular provides automated schematics that handle edge cases, update tests, and ensure correctness. Manual migration should ONLY be used for patterns not covered by CLI tools.

Anti Reversing Techniques

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

AUTHORIZED USE ONLY: This skill contains dual-use security techniques. Before proceeding with any bypass or analysis:

Verify authorization: Confirm you have explicit written permission from the software owner, or are operating within a legitimate security context (CTF, authorized pentest, malware analysis, security research)

Document scope: Ensure your activities fall within the defined scope of your authorization

Legal compliance: Understand that unauthorized bypassing of software protection may violate laws (CFAA, DMCA anti-circumvention, etc.)

Legitimate use cases: Malware analysis, authorized penetration testing, CTF competitions, academic security research, analyzing software you own/have rights to

Api Design Principles

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

API Design Principles

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers and stand the test of time.

When to Use This Skill

Designing new REST or GraphQL APIs
Refactoring existing APIs for better usability
Establishing API design standards for your team
Reviewing API specifications before implementation
Migrating between API paradigms (REST to GraphQL, etc.)
Creating developer-friendly API documentation
Optimizing APIs for specific use cases (mobile, third-party integrations)

Core Concepts

1. RESTful Design Principles

Resource-Oriented Architecture

Api Integration Specialist

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

API Integration Specialist

Expert guidance for integrating external APIs into applications with production-ready patterns, security best practices, and comprehensive error handling.

When to Use This Skill

Use this skill when:

Integrating third-party APIs (Stripe, Twilio, SendGrid, etc.)
Building API client libraries or wrappers
Implementing OAuth 2.0, API keys, or JWT authentication
Setting up webhooks and event-driven integrations
Handling rate limits, retries, and circuit breakers
Transforming API responses for application use
Debugging API integration issues

Core Integration Principles

1. Authentication & Security

API Key Management:

Architecture Decision Records

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

Architecture Decision Records

Comprehensive patterns for creating, maintaining, and managing Architecture Decision Records (ADRs) that capture the context and rationale behind significant technical decisions.

When to Use This Skill

Making significant architectural decisions
Documenting technology choices
Recording design trade-offs
Onboarding new team members
Reviewing historical decisions
Establishing decision-making processes

Core Concepts

1. What is an ADR?

An Architecture Decision Record captures:

Context: Why we needed to make a decision
Decision: What we decided
Consequences: What happens as a result

2. When to Write an ADR

Write ADR	Skip ADR
New framework adoption	Minor version upgrades
Database technology choice	Bug fixes
API design patterns	Implementation details
Security architecture	Routine maintenance
Integration patterns	Configuration changes

3. ADR Lifecycle

Proposed → Accepted → Deprecated → Superseded
 ↓
 Rejected

Templates

Template 1: Standard ADR (MADR Format)

 1# ADR-0001: Use PostgreSQL as Primary Database
 2
 3## Status
 4
 5Accepted
 6
 7## Context
 8
 9We need to select a primary database for our new e-commerce platform. The system
 10will handle:
 11
 12- ~10,000 concurrent users
 13- Complex product catalog with hierarchical categories
 14- Transaction processing for orders and payments
 15- Full-text search for products
 16- Geospatial queries for store locator
 17
 18The team has experience with MySQL, PostgreSQL, and MongoDB. We need ACID
 19compliance for financial transactions.
 20
 21## Decision Drivers
 22
 23- **Must have ACID compliance** for payment processing
 24- **Must support complex queries** for reporting
 25- **Should support full-text search** to reduce infrastructure complexity
 26- **Should have good JSON support** for flexible product attributes
 27- **Team familiarity** reduces onboarding time
 28
 29## Considered Options
 30
 31### Option 1: PostgreSQL
 32
 33- **Pros**: ACID compliant, excellent JSON support (JSONB), built-in full-text
 34 search, PostGIS for geospatial, team has experience
 35- **Cons**: Slightly more complex replication setup than MySQL
 36
 37### Option 2: MySQL
 38
 39- **Pros**: Very familiar to team, simple replication, large community
 40- **Cons**: Weaker JSON support, no built-in full-text search (need
 41 Elasticsearch), no geospatial without extensions
 42
 43### Option 3: MongoDB
 44
 45- **Pros**: Flexible schema, native JSON, horizontal scaling
 46- **Cons**: No ACID for multi-document transactions (at decision time),
 47 team has limited experience, requires schema design discipline
 48
 49## Decision
 50
 51We will use **PostgreSQL 15** as our primary database.
 52
 53## Rationale
 54
 55PostgreSQL provides the best balance of:
 56
 571. **ACID compliance** essential for e-commerce transactions
 582. **Built-in capabilities** (full-text search, JSONB, PostGIS) reduce
 59 infrastructure complexity
 603. **Team familiarity** with SQL databases reduces learning curve
 614. **Mature ecosystem** with excellent tooling and community support
 62
 63The slight complexity in replication is outweighed by the reduction in
 64additional services (no separate Elasticsearch needed).
 65
 66## Consequences
 67
 68### Positive
 69
 70- Single database handles transactions, search, and geospatial queries
 71- Reduced operational complexity (fewer services to manage)
 72- Strong consistency guarantees for financial data
 73- Team can leverage existing SQL expertise
 74
 75### Negative
 76
 77- Need to learn PostgreSQL-specific features (JSONB, full-text search syntax)
 78- Vertical scaling limits may require read replicas sooner
 79- Some team members need PostgreSQL-specific training
 80
 81### Risks
 82
 83- Full-text search may not scale as well as dedicated search engines
 84- Mitigation: Design for potential Elasticsearch addition if needed
 85
 86## Implementation Notes
 87
 88- Use JSONB for flexible product attributes
 89- Implement connection pooling with PgBouncer
 90- Set up streaming replication for read replicas
 91- Use pg_trgm extension for fuzzy search
 92
 93## Related Decisions
 94
 95- ADR-0002: Caching Strategy (Redis) - complements database choice
 96- ADR-0005: Search Architecture - may supersede if Elasticsearch needed
 97
 98## References
 99
100- [PostgreSQL JSON Documentation](https://www.postgresql.org/docs/current/datatype-json.html)
101- [PostgreSQL Full Text Search](https://www.postgresql.org/docs/current/textsearch.html)
102- Internal: Performance benchmarks in `/docs/benchmarks/database-comparison.md`

Template 2: Lightweight ADR

 1# ADR-0012: Adopt TypeScript for Frontend Development
 2
 3**Status**: Accepted
 4**Date**: 2024-01-15
 5**Deciders**: @alice, @bob, @charlie
 6
 7## Context
 8
 9Our React codebase has grown to 50+ components with increasing bug reports
10related to prop type mismatches and undefined errors. PropTypes provide
11runtime-only checking.
12
13## Decision
14
15Adopt TypeScript for all new frontend code. Migrate existing code incrementally.
16
17## Consequences
18
19**Good**: Catch type errors at compile time, better IDE support, self-documenting
20code.
21
22**Bad**: Learning curve for team, initial slowdown, build complexity increase.
23
24**Mitigations**: TypeScript training sessions, allow gradual adoption with
25`allowJs: true`.

Template 3: Y-Statement Format

1# ADR-0015: API Gateway Selection
2
3In the context of **building a microservices architecture**,
4facing **the need for centralized API management, authentication, and rate limiting**,
5we decided for **Kong Gateway**
6and against **AWS API Gateway and custom Nginx solution**,
7to achieve **vendor independence, plugin extensibility, and team familiarity with Lua**,
8accepting that **we need to manage Kong infrastructure ourselves**.

Template 4: ADR for Deprecation

 1# ADR-0020: Deprecate MongoDB in Favor of PostgreSQL
 2
 3## Status
 4
 5Accepted (Supersedes ADR-0003)
 6
 7## Context
 8
 9ADR-0003 (2021) chose MongoDB for user profile storage due to schema flexibility
10needs. Since then:
11
12- MongoDB's multi-document transactions remain problematic for our use case
13- Our schema has stabilized and rarely changes
14- We now have PostgreSQL expertise from other services
15- Maintaining two databases increases operational burden
16
17## Decision
18
19Deprecate MongoDB and migrate user profiles to PostgreSQL.
20
21## Migration Plan
22
231. **Phase 1** (Week 1-2): Create PostgreSQL schema, dual-write enabled
242. **Phase 2** (Week 3-4): Backfill historical data, validate consistency
253. **Phase 3** (Week 5): Switch reads to PostgreSQL, monitor
264. **Phase 4** (Week 6): Remove MongoDB writes, decommission
27
28## Consequences
29
30### Positive
31
32- Single database technology reduces operational complexity
33- ACID transactions for user data
34- Team can focus PostgreSQL expertise
35
36### Negative
37
38- Migration effort (~4 weeks)
39- Risk of data issues during migration
40- Lose some schema flexibility
41
42## Lessons Learned
43
44Document from ADR-0003 experience:
45
46- Schema flexibility benefits were overestimated
47- Operational cost of multiple databases was underestimated
48- Consider long-term maintenance in technology decisions

Template 5: Request for Comments (RFC) Style

 1# RFC-0025: Adopt Event Sourcing for Order Management
 2
 3## Summary
 4
 5Propose adopting event sourcing pattern for the order management domain to
 6improve auditability, enable temporal queries, and support business analytics.
 7
 8## Motivation
 9
10Current challenges:
11
121. Audit requirements need complete order history
132. "What was the order state at time X?" queries are impossible
143. Analytics team needs event stream for real-time dashboards
154. Order state reconstruction for customer support is manual
16
17## Detailed Design
18
19### Event Store

OrderCreated { orderId, customerId, items[], timestamp } OrderItemAdded { orderId, item, timestamp } OrderItemRemoved { orderId, itemId, timestamp } PaymentReceived { orderId, amount, paymentId, timestamp } OrderShipped { orderId, trackingNumber, timestamp }

Architecture Patterns

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

Architecture Patterns

Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.

When to Use This Skill

Designing new backend systems from scratch
Refactoring monolithic applications for better maintainability
Establishing architecture standards for your team
Migrating from tightly coupled to loosely coupled architectures
Implementing domain-driven design principles
Creating testable and mockable codebases
Planning microservices decomposition

Core Concepts

1. Clean Architecture (Uncle Bob)

Layers (dependency flows inward):

Artifacts Builder

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

Artifacts Builder

To build powerful frontend claude.ai artifacts, follow these steps:

Initialize the frontend repo using scripts/init-artifact.sh
Develop your artifact by editing the generated code
Bundle all code into a single HTML file using scripts/bundle-artifact.sh
Display artifact to user
(Optional) Test the artifact

Stack: React 18 + TypeScript + Vite + Parcel (bundling) + Tailwind CSS + shadcn/ui

Design & Style Guidelines

VERY IMPORTANT: To avoid what is often referred to as “AI slop”, avoid using excessive centered layouts, purple gradients, uniform rounded corners, and Inter font.

Async Python Patterns

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

Async Python Patterns

Comprehensive guidance for implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for building high-performance, non-blocking systems.

When to Use This Skill

Building async web APIs (FastAPI, aiohttp, Sanic)
Implementing concurrent I/O operations (database, file, network)
Creating web scrapers with concurrent requests
Developing real-time applications (WebSocket servers, chat systems)
Processing multiple independent tasks simultaneously
Building microservices with async communication
Optimizing I/O-bound workloads
Implementing async background tasks and queues

Core Concepts

1. Event Loop

The event loop is the heart of asyncio, managing and scheduling asynchronous tasks.

Auth Implementation Patterns

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

Authentication & Authorization Implementation Patterns

Build secure, scalable authentication and authorization systems using industry-standard patterns and modern best practices.

When to Use This Skill

Implementing user authentication systems
Securing REST or GraphQL APIs
Adding OAuth2/social login
Implementing role-based access control (RBAC)
Designing session management
Migrating authentication systems
Debugging auth issues
Implementing SSO or multi-tenancy

Core Concepts

1. Authentication vs Authorization

Authentication (AuthN): Who are you?

Verifying identity (username/password, OAuth, biometrics)
Issuing credentials (sessions, tokens)
Managing login/logout

Authorization (AuthZ): What can you do?

AutoGPT Agents - 构建自主AI工作流

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

AutoGPT - Autonomous AI Agent Platform

Comprehensive platform for building, deploying, and managing continuous AI agents through a visual interface or development toolkit.

When to use AutoGPT

Use AutoGPT when:

Building autonomous agents that run continuously
Creating visual workflow-based AI agents
Deploying agents with external triggers (webhooks, schedules)
Building complex multi-step automation pipelines
Need a no-code/low-code agent builder

Key features:

Visual Agent Builder: Drag-and-drop node-based workflow editor
Continuous Execution: Agents run persistently with triggers
Marketplace: Pre-built agents and blocks to share/reuse
Block System: Modular components for LLM, tools, integrations
Forge Toolkit: Developer tools for custom agent creation
Benchmark System: Standardized agent performance testing

Use alternatives instead:

Backend Dev Guidelines

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

Backend Development Guidelines

Purpose

Establish consistency and best practices across backend microservices (blog-api, auth-service, notifications-service) using modern Node.js/Express/TypeScript patterns.

When to Use This Skill

Automatically activates when working on:

Creating or modifying routes, endpoints, APIs
Building controllers, services, repositories
Implementing middleware (auth, validation, error handling)
Database operations with Prisma
Error tracking with Sentry
Input validation with Zod
Configuration management
Backend testing and refactoring

Quick Start

New Backend Feature Checklist

Route: Clean definition, delegate to controller
Controller: Extend BaseController
Service: Business logic with DI
Repository: Database access (if complex)
Validation: Zod schema
Sentry: Error tracking
Tests: Unit + integration tests
Config: Use unifiedConfig

New Microservice Checklist

Directory structure (see architecture-overview.md)
instrument.ts for Sentry
unifiedConfig setup
BaseController class
Middleware stack
Error boundary
Testing framework

Architecture Overview

Layered Architecture

HTTP Request
 ↓
Routes (routing only)
 ↓
Controllers (request handling)
 ↓
Services (business logic)
 ↓
Repositories (data access)
 ↓
Database (Prisma)

Key Principle: Each layer has ONE responsibility.

Bash Defensive Patterns

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

Bash Defensive Patterns

Comprehensive guidance for writing production-ready Bash scripts using defensive programming techniques, error handling, and safety best practices to prevent common pitfalls and ensure reliability.

When to Use This Skill

Writing production automation scripts
Building CI/CD pipeline scripts
Creating system administration utilities
Developing error-resilient deployment automation
Writing scripts that must handle edge cases safely
Building maintainable shell script libraries
Implementing comprehensive logging and monitoring
Creating scripts that must work across different platforms

Core Defensive Principles

1. Strict Mode

Enable bash strict mode at the start of every script to catch errors early.

Bats Testing Patterns

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

Bats Testing Patterns

Comprehensive guidance for writing comprehensive unit tests for shell scripts using Bats (Bash Automated Testing System), including test patterns, fixtures, and best practices for production-grade shell testing.

When to Use This Skill

Writing unit tests for shell scripts
Implementing test-driven development (TDD) for scripts
Setting up automated testing in CI/CD pipelines
Testing edge cases and error conditions
Validating behavior across different shell environments
Building maintainable test suites for scripts
Creating fixtures for complex test scenarios
Testing multiple shell dialects (bash, sh, dash)

Bats Fundamentals

What is Bats?

Bats (Bash Automated Testing System) is a TAP (Test Anything Protocol) compliant testing framework for shell scripts that provides:

Benchling Integration

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

Benchling Integration

Overview

Benchling is a cloud platform for life sciences R&D. Access registry entities (DNA, proteins), inventory, electronic lab notebooks, and workflows programmatically via Python SDK and REST API.

When to Use This Skill

This skill should be used when:

Working with Benchling’s Python SDK or REST API
Managing biological sequences (DNA, RNA, proteins) and registry entities
Automating inventory operations (samples, containers, locations, transfers)
Creating or querying electronic lab notebook entries
Building workflow automations or Benchling Apps
Syncing data between Benchling and external systems
Querying the Benchling Data Warehouse for analytics
Setting up event-driven integrations with AWS EventBridge

Core Capabilities

1. Authentication & Setup

Python SDK Installation:

Billing Automation

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

Billing Automation

Master automated billing systems including recurring billing, invoice generation, dunning management, proration, and tax calculation.

When to Use This Skill

Implementing SaaS subscription billing
Automating invoice generation and delivery
Managing failed payment recovery (dunning)
Calculating prorated charges for plan changes
Handling sales tax, VAT, and GST
Processing usage-based billing
Managing billing cycles and renewals

Core Concepts

1. Billing Cycles

Common Intervals:

Monthly (most common for SaaS)
Annual (discounted long-term)
Quarterly
Weekly
Custom (usage-based, per-seat)

2. Subscription States

trial → active → past_due → canceled
 → paused → resumed

3. Dunning Management

Automated process to recover failed payments through:

Binary Analysis Patterns

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

Binary Analysis Patterns

Comprehensive patterns and techniques for analyzing compiled binaries, understanding assembly code, and reconstructing program logic.

Disassembly Fundamentals

x86-64 Instruction Patterns

Function Prologue/Epilogue

 1; Standard prologue
 2push rbp ; Save base pointer
 3mov rbp, rsp ; Set up stack frame
 4sub rsp, 0x20 ; Allocate local variables
 5
 6; Leaf function (no calls)
 7; May skip frame pointer setup
 8sub rsp, 0x18 ; Just allocate locals
 9
10; Standard epilogue
11mov rsp, rbp ; Restore stack pointer
12pop rbp ; Restore base pointer
13ret
14
15; Leave instruction (equivalent)
16leave ; mov rsp, rbp; pop rbp
17ret

Calling Conventions

System V AMD64 (Linux, macOS)

Bit Cli

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

Bit CLI Quick Reference

usage: bit [–version] [–help] []

bit documentation: https://bit.dev/

System & Utility help display available commands and usage information version display the installed Bit version config manage Bit configuration settings globals display global directories and paths used by Bit system access system-level operations and debugging tools doctor diagnose and troubleshoot workspace issues clear-cache remove cached data to resolve stale data issues

Brand Guidelines

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

Anthropic Brand Styling

Overview

To access Anthropic’s official brand identity and style resources, use this skill.

Keywords: branding, corporate identity, visual identity, post-processing, styling, brand colors, typography, Anthropic brand, visual formatting, visual design

Brand Guidelines

Colors

Main Colors:

Dark: #141413 - Primary text and dark backgrounds
Light: #faf9f5 - Light backgrounds and text on dark
Mid Gray: #b0aea5 - Secondary elements
Light Gray: #e8e6dc - Subtle backgrounds

Accent Colors:

Orange: #d97757 - Primary accent
Blue: #6a9bcc - Secondary accent
Green: #788c5d - Tertiary accent

Typography

Headings: Poppins (with Arial fallback)
Body Text: Lora (with Georgia fallback)
Note: Fonts should be pre-installed in your environment for best results

Features

Smart Font Application

Applies Poppins font to headings (24pt and larger)
Applies Lora font to body text
Automatically falls back to Arial/Georgia if custom fonts unavailable
Preserves readability across all systems

Text Styling

Headings (24pt+): Poppins font
Body text: Lora font
Smart color selection based on background
Preserves text hierarchy and formatting

Shape and Accent Colors

Non-text shapes use accent colors
Cycles through orange, blue, and green accents
Maintains visual interest while staying on-brand

Technical Details

Font Management

Uses system-installed Poppins and Lora fonts when available
Provides automatic fallback to Arial (headings) and Georgia (body)
No font installation required - works with existing system fonts
For best results, pre-install Poppins and Lora fonts in your environment

Color Application

Uses RGB color values for precise brand matching
Applied via python-pptx’s RGBColor class
Maintains color fidelity across different systems

Build Tui View

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

📝 SELF-UPDATING DOCUMENT: This skill automatically updates itself when inaccuracies are discovered or new patterns are learned. Always verify information against the actual codebase and update this file when needed.

Overview

This skill provides instructions for creating and maintaining Terminal User Interface (TUI) views in the Hatchet CLI using bubbletea and lipgloss. The TUI system uses a modular view architecture where individual views are isolated in separate files within the views/ directory.

Byethrow

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

About byethrow

@praha/byethrow is a lightweight, tree-shakable Result type library for handling fallible operations in JavaScript and TypeScript. It provides a simple, consistent API for managing errors and results without throwing exceptions.

For detailed API references and usage examples, refer to the documentation in node_modules/@praha/byethrow-docs/docs/**/*.md.

Documentation CLI

The byethrow documentation CLI provides commands to browse, search, and navigate documentation directly from your terminal.

`list` command

List all available documentation organized by sections.

Cache Components

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

Next.js Cache Components

Auto-activation: This skill activates automatically in projects with cacheComponents: true in next.config.

Project Detection

When starting work in a Next.js project, check if Cache Components are enabled:

1# Check next.config.ts or next.config.js for cacheComponents
2grep -r "cacheComponents" next.config.* 2>/dev/null

If cacheComponents: true is found, apply this skill’s patterns proactively when:

Writing React Server Components
Implementing data fetching
Creating Server Actions with mutations
Optimizing page performance
Reviewing existing component code

Cache Components enable Partial Prerendering (PPR) - mixing static HTML shells with dynamic streaming content for optimal performance.

Ceo Advisor

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

CEO Advisor

Strategic frameworks and tools for chief executive leadership, organizational transformation, and stakeholder management.

Keywords

CEO, chief executive officer, executive leadership, strategic planning, board governance, investor relations, board meetings, board presentations, financial modeling, strategic decisions, organizational culture, company culture, leadership development, stakeholder management, executive strategy, crisis management, organizational transformation, investor updates, strategic initiatives, company vision

Quick Start

For Strategic Planning

1python scripts/strategy_analyzer.py

Analyzes strategic position and generates actionable recommendations.

Changelog

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

Changelog Maintenance

You are a changelog maintenance specialist for the IdeaVim project. Your job is to keep the changelog (CHANGES.md) and build.gradle.kts changeNotes in sync with code changes.

Historical Context

The changelog was actively maintained until version 2.9.0
There’s a gap from 2.10.0 through 2.27.0 where changelog wasn’t maintained
We’re resuming changelog maintenance from version 2.28.0 onwards
Between 2.9.0 and 2.28.0, include this note: “Changelog was not maintained for versions 2.10.0 through 2.27.0”

Changelog Structure

[To Be Released] Section

All unreleased changes from master branch go here
When a release is made, this section becomes the new version section
Create a new empty [To Be Released] section after each release

Version Entry Format

## 2.28.0, 2024-MM-DD

### Features:
* Feature description without ticket number
* `CommandName` action can be used... | [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX)

### Fixes:
* [VIM-XXXX](https://youtrack.jetbrains.com/issue/VIM-XXXX) Bug fix description

### Changes:
* Other changes

How to Gather Information

1. Check Current State

Read CHANGES.md to find the last documented version
Important: Only read the top portion of CHANGES.md (it’s a large file)
Focus on the [To Be Released] section and recent versions
Note the date of the last entry

1.5. Check the Last Processed Commit (Automated Workflow)

When running via the GitHub Actions workflow, check if a last processed commit SHA is provided in the prompt.

Changelog Automation

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

Changelog Automation

Patterns and tools for automating changelog generation, release notes, and version management following industry standards.

When to Use This Skill

Setting up automated changelog generation
Implementing Conventional Commits
Creating release note workflows
Standardizing commit message formats
Generating GitHub/GitLab release notes
Managing semantic versioning

Core Concepts

1. Keep a Changelog Format

 1# Changelog
 2
 3All notable changes to this project will be documented in this file.
 4
 5The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 6and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 7
 8## [Unreleased]
 9
10### Added
11
12- New feature X
13
14## [1.2.0] - 2024-01-15
15
16### Added
17
18- User profile avatars
19- Dark mode support
20
21### Changed
22
23- Improved loading performance by 40%
24
25### Deprecated
26
27- Old authentication API (use v2)
28
29### Removed
30
31- Legacy payment gateway
32
33### Fixed
34
35- Login timeout issue (#123)
36
37### Security
38
39- Updated dependencies for CVE-2024-1234
40
41[Unreleased]: https://github.com/user/repo/compare/v1.2.0...HEAD
42[1.2.0]: https://github.com/user/repo/compare/v1.1.0...v1.2.0

2. Conventional Commits

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

Type	Description	Changelog Section
`feat`	New feature	Added
`fix`	Bug fix	Fixed
`docs`	Documentation	(usually excluded)
`style`	Formatting	(usually excluded)
`refactor`	Code restructure	Changed
`perf`	Performance	Changed
`test`	Tests	(usually excluded)
`chore`	Maintenance	(usually excluded)
`ci`	CI changes	(usually excluded)
`build`	Build system	(usually excluded)
`revert`	Revert commit	Removed

3. Semantic Versioning

MAJOR.MINOR.PATCH

MAJOR: Breaking changes (feat! or BREAKING CHANGE)
MINOR: New features (feat)
PATCH: Bug fixes (fix)

Implementation

Method 1: Conventional Changelog (Node.js)

 1# Install tools
 2npm install -D @commitlint/cli @commitlint/config-conventional
 3npm install -D husky
 4npm install -D standard-version
 5# or
 6npm install -D semantic-release
 7
 8# Setup commitlint
 9cat > commitlint.config.js << 'EOF'
10module.exports = {
11 extends: ['@commitlint/config-conventional'],
12 rules: {
13 'type-enum': [
14 2,
15 'always',
16 [
17 'feat',
18 'fix',
19 'docs',
20 'style',
21 'refactor',
22 'perf',
23 'test',
24 'chore',
25 'ci',
26 'build',
27 'revert',
28 ],
29 ],
30 'subject-case': [2, 'never', ['start-case', 'pascal-case', 'upper-case']],
31 'subject-max-length': [2, 'always', 72],
32 },
33};
34EOF
35
36# Setup husky
37npx husky init
38echo "npx --no -- commitlint --edit \$1" > .husky/commit-msg

Method 2: standard-version Configuration

 1// .versionrc.js
 2module.exports = {
 3 types: [
 4 { type: "feat", section: "Features" },
 5 { type: "fix", section: "Bug Fixes" },
 6 { type: "perf", section: "Performance Improvements" },
 7 { type: "revert", section: "Reverts" },
 8 { type: "docs", section: "Documentation", hidden: true },
 9 { type: "style", section: "Styles", hidden: true },
10 { type: "chore", section: "Miscellaneous", hidden: true },
11 { type: "refactor", section: "Code Refactoring", hidden: true },
12 { type: "test", section: "Tests", hidden: true },
13 { type: "build", section: "Build System", hidden: true },
14 { type: "ci", section: "CI/CD", hidden: true },
15 ],
16 commitUrlFormat: "{{host}}/{{owner}}/{{repository}}/commit/{{hash}}",
17 compareUrlFormat:
18 "{{host}}/{{owner}}/{{repository}}/compare/{{previousTag}}...{{currentTag}}",
19 issueUrlFormat: "{{host}}/{{owner}}/{{repository}}/issues/{{id}}",
20 userUrlFormat: "{{host}}/{{user}}",
21 releaseCommitMessageFormat: "chore(release): {{currentTag}}",
22 scripts: {
23 prebump: 'echo "Running prebump"',
24 postbump: 'echo "Running postbump"',
25 prechangelog: 'echo "Running prechangelog"',
26 postchangelog: 'echo "Running postchangelog"',
27 },
28};

 1// package.json scripts
 2{
 3 "scripts": {
 4 "release": "standard-version",
 5 "release:minor": "standard-version --release-as minor",
 6 "release:major": "standard-version --release-as major",
 7 "release:patch": "standard-version --release-as patch",
 8 "release:dry": "standard-version --dry-run"
 9 }
10}

Method 3: semantic-release (Full Automation)

 1// release.config.js
 2module.exports = {
 3 branches: [
 4 "main",
 5 { name: "beta", prerelease: true },
 6 { name: "alpha", prerelease: true },
 7 ],
 8 plugins: [
 9 "@semantic-release/commit-analyzer",
10 "@semantic-release/release-notes-generator",
11 [
12 "@semantic-release/changelog",
13 {
14 changelogFile: "CHANGELOG.md",
15 },
16 ],
17 [
18 "@semantic-release/npm",
19 {
20 npmPublish: true,
21 },
22 ],
23 [
24 "@semantic-release/github",
25 {
26 assets: ["dist/**/*.js", "dist/**/*.css"],
27 },
28 ],
29 [
30 "@semantic-release/git",
31 {
32 assets: ["CHANGELOG.md", "package.json"],
33 message:
34 "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}",
35 },
36 ],
37 ],
38};

Method 4: GitHub Actions Workflow

 1# .github/workflows/release.yml
 2name: Release
 3
 4on:
 5 push:
 6 branches: [main]
 7 workflow_dispatch:
 8 inputs:
 9 release_type:
10 description: "Release type"
11 required: true
12 default: "patch"
13 type: choice
14 options:
15 - patch
16 - minor
17 - major
18
19permissions:
20 contents: write
21 pull-requests: write
22
23jobs:
24 release:
25 runs-on: ubuntu-latest
26 steps:
27 - uses: actions/checkout@v4
28 with:
29 fetch-depth: 0
30 token: ${{ secrets.GITHUB_TOKEN }}
31
32 - uses: actions/setup-node@v4
33 with:
34 node-version: "20"
35 cache: "npm"
36
37 - run: npm ci
38
39 - name: Configure Git
40 run: |
41 git config user.name "github-actions[bot]"
42 git config user.email "github-actions[bot]@users.noreply.github.com"
43
44 - name: Run semantic-release
45 env:
46 GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
47 NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
48 run: npx semantic-release
49
50 # Alternative: manual release with standard-version
51 manual-release:
52 if: github.event_name == 'workflow_dispatch'
53 runs-on: ubuntu-latest
54 steps:
55 - uses: actions/checkout@v4
56 with:
57 fetch-depth: 0
58
59 - uses: actions/setup-node@v4
60 with:
61 node-version: "20"
62
63 - run: npm ci
64
65 - name: Configure Git
66 run: |
67 git config user.name "github-actions[bot]"
68 git config user.email "github-actions[bot]@users.noreply.github.com"
69
70 - name: Bump version and generate changelog
71 run: npx standard-version --release-as ${{ inputs.release_type }}
72
73 - name: Push changes
74 run: git push --follow-tags origin main
75
76 - name: Create GitHub Release
77 uses: softprops/action-gh-release@v1
78 with:
79 tag_name: ${{ steps.version.outputs.tag }}
80 body_path: RELEASE_NOTES.md
81 generate_release_notes: true

Method 5: git-cliff (Rust-based, Fast)

 1# cliff.toml
 2[changelog]
 3header = """
 4# Changelog
 5
 6All notable changes to this project will be documented in this file.
 7
 8"""
 9body = """
10{% if version %}\
11 ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
12{% else %}\
13 ## [Unreleased]
14{% endif %}\
15{% for group, commits in commits | group_by(attribute="group") %}
16 ### {{ group | upper_first }}
17 {% for commit in commits %}
18 - {% if commit.scope %}**{{ commit.scope }}:** {% endif %}\
19 {{ commit.message | upper_first }}\
20 {% if commit.github.pr_number %} ([#{{ commit.github.pr_number }}](https://github.com/owner/repo/pull/{{ commit.github.pr_number }})){% endif %}\
21 {% endfor %}
22{% endfor %}
23"""
24footer = """
25{% for release in releases -%}
26 {% if release.version -%}
27 {% if release.previous.version -%}
28 [{{ release.version | trim_start_matches(pat="v") }}]: \
29 https://github.com/owner/repo/compare/{{ release.previous.version }}...{{ release.version }}
30 {% endif -%}
31 {% else -%}
32 [unreleased]: https://github.com/owner/repo/compare/{{ release.previous.version }}...HEAD
33 {% endif -%}
34{% endfor %}
35"""
36trim = true
37
38[git]
39conventional_commits = true
40filter_unconventional = true
41split_commits = false
42commit_parsers = [
43 { message = "^feat", group = "Features" },
44 { message = "^fix", group = "Bug Fixes" },
45 { message = "^doc", group = "Documentation" },
46 { message = "^perf", group = "Performance" },
47 { message = "^refactor", group = "Refactoring" },
48 { message = "^style", group = "Styling" },
49 { message = "^test", group = "Testing" },
50 { message = "^chore\\(release\\)", skip = true },
51 { message = "^chore", group = "Miscellaneous" },
52]
53filter_commits = false
54tag_pattern = "v[0-9]*"
55skip_tags = ""
56ignore_tags = ""
57topo_order = false
58sort_commits = "oldest"
59
60[github]
61owner = "owner"
62repo = "repo"

1# Generate changelog
2git cliff -o CHANGELOG.md
3
4# Generate for specific range
5git cliff v1.0.0..v2.0.0 -o RELEASE_NOTES.md
6
7# Preview without writing
8git cliff --unreleased --dry-run

Method 6: Python (commitizen)

 1# pyproject.toml
 2[tool.commitizen]
 3name = "cz_conventional_commits"
 4version = "1.0.0"
 5version_files = [
 6 "pyproject.toml:version",
 7 "src/__init__.py:__version__",
 8]
 9tag_format = "v$version"
10update_changelog_on_bump = true
11changelog_incremental = true
12changelog_start_rev = "v0.1.0"
13
14[tool.commitizen.customize]
15message_template = "{{change_type}}{% if scope %}({{scope}}){% endif %}: {{message}}"
16schema = "<type>(<scope>): <subject>"
17schema_pattern = "^(feat|fix|docs|style|refactor|perf|test|chore)(\\(\\w+\\))?:\\s.*"
18bump_pattern = "^(feat|fix|perf|refactor)"
19bump_map = {"feat" = "MINOR", "fix" = "PATCH", "perf" = "PATCH", "refactor" = "PATCH"}

 1# Install
 2pip install commitizen
 3
 4# Create commit interactively
 5cz commit
 6
 7# Bump version and update changelog
 8cz bump --changelog
 9
10# Check commits
11cz check --rev-range HEAD~5..HEAD

Release Notes Templates

GitHub Release Template

 1## What's Changed
 2
 3### 🚀 Features
 4
 5{{ range .Features }}
 6
 7- {{ .Title }} by @{{ .Author }} in #{{ .PR }}
 8 {{ end }}
 9
10### 🐛 Bug Fixes
11
12{{ range .Fixes }}
13
14- {{ .Title }} by @{{ .Author }} in #{{ .PR }}
15 {{ end }}
16
17### 📚 Documentation
18
19{{ range .Docs }}
20
21- {{ .Title }} by @{{ .Author }} in #{{ .PR }}
22 {{ end }}
23
24### 🔧 Maintenance
25
26{{ range .Chores }}
27
28- {{ .Title }} by @{{ .Author }} in #{{ .PR }}
29 {{ end }}
30
31## New Contributors
32
33{{ range .NewContributors }}
34
35- @{{ .Username }} made their first contribution in #{{ .PR }}
36 {{ end }}
37
38**Full Changelog**: https://github.com/owner/repo/compare/v{{ .Previous }}...v{{ .Current }}

Internal Release Notes

 1# Release v2.1.0 - January 15, 2024
 2
 3## Summary
 4
 5This release introduces dark mode support and improves checkout performance
 6by 40%. It also includes important security updates.
 7
 8## Highlights
 9
10### 🌙 Dark Mode
11
12Users can now switch to dark mode from settings. The preference is
13automatically saved and synced across devices.
14
15### ⚡ Performance
16
17- Checkout flow is 40% faster
18- Reduced bundle size by 15%
19
20## Breaking Changes
21
22None in this release.
23
24## Upgrade Guide
25
26No special steps required. Standard deployment process applies.
27
28## Known Issues
29
30- Dark mode may flicker on initial load (fix scheduled for v2.1.1)
31
32## Dependencies Updated
33
34| Package | From | To | Reason |
35| ------- | ------- | ------- | ------------------------ |
36| react | 18.2.0 | 18.3.0 | Performance improvements |
37| lodash | 4.17.20 | 4.17.21 | Security patch |

Commit Message Examples

 1# Feature with scope
 2feat(auth): add OAuth2 support for Google login
 3
 4# Bug fix with issue reference
 5fix(checkout): resolve race condition in payment processing
 6
 7Closes #123
 8
 9# Breaking change
10feat(api)!: change user endpoint response format
11
12BREAKING CHANGE: The user endpoint now returns `userId` instead of `id`.
13Migration guide: Update all API consumers to use the new field name.
14
15# Multiple paragraphs
16fix(database): handle connection timeouts gracefully
17
18Previously, connection timeouts would cause the entire request to fail
19without retry. This change implements exponential backoff with up to
203 retries before failing.
21
22The timeout threshold has been increased from 5s to 10s based on p99
23latency analysis.
24
25Fixes #456
26Reviewed-by: @alice

Best Practices

Do’s

Follow Conventional Commits - Enables automation
Write clear messages - Future you will thank you
Reference issues - Link commits to tickets
Use scopes consistently - Define team conventions
Automate releases - Reduce manual errors

Don’ts

Don’t mix changes - One logical change per commit
Don’t skip validation - Use commitlint
Don’t manual edit - Generated changelogs only
Don’t forget breaking changes - Mark with ! or footer
Don’t ignore CI - Validate commits in pipeline

Resources

Changelog Generator

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

Changelog Generator

This skill transforms technical git commits into polished, user-friendly changelogs that your customers and users will actually understand and appreciate.

When to Use This Skill

Preparing release notes for a new version
Creating weekly or monthly product update summaries
Documenting changes for customers
Writing changelog entries for app store submissions
Generating update notifications
Creating internal release documentation
Maintaining a public changelog/product updates page

What This Skill Does

Scans Git History: Analyzes commits from a specific time period or between versions
Categorizes Changes: Groups commits into logical categories (features, improvements, bug fixes, breaking changes, security)
Translates Technical → User-Friendly: Converts developer commits into customer language
Formats Professionally: Creates clean, structured changelog entries
Filters Noise: Excludes internal commits (refactoring, tests, etc.)
Follows Best Practices: Applies changelog guidelines and your brand voice

How to Use

Basic Usage

From your project repository:

Claude Opus 4 5 Migration

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

Opus 4.5 Migration Guide

One-shot migration from Sonnet 4.0, Sonnet 4.5, or Opus 4.1 to Opus 4.5.

Migration Workflow

Search codebase for model strings and API calls
Update model strings to Opus 4.5 (see platform-specific strings below)
Remove unsupported beta headers
Add effort parameter set to "high" (see references/effort.md)
Summarize all changes made
Tell the user: “If you encounter any issues with Opus 4.5, let me know and I can help adjust your prompts.”

Model String Updates

Identify which platform the codebase uses, then replace model strings accordingly.

Claude Skills

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

Claude Skills Meta-Skill

Turn scattered domain material into a Skill that is reusable, maintainable, and reliably activatable:

SKILL.md as the entrypoint (triggers, constraints, patterns, examples)
references/ for long-form evidence and navigation
optional scripts/ and assets/ for scaffolding and templates

When to Use This Skill

Trigger this meta-skill when you need to:

Create a new Skill from scratch from docs/specs/repos
Refactor an existing Skill (too long, unclear, inconsistent, misfires)
Design reliable activation (frontmatter + triggers + boundaries)
Extract a clean Quick Reference from large material
Split long content into navigable references/
Add a quality gate and a validator

Not For / Boundaries

This meta-skill is NOT:

Clickhouse Query

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

ClickHouse Query Testing

Use this skill to run ad-hoc ClickHouse queries for analytics, metrics analysis, and debugging.

Running Queries

Use the included query script:

1node .claude/skills/clickhouse-query/query.mjs "SELECT count() FROM views"

Options

Flag	Description
`--explain`	Show query execution plan
`--writable`	Allow write operations (requires user permission)
`--timeout <s>`, `-t`	Query timeout in seconds (default: 30)
`--file`, `-f`	Read query from a file
`--json`	Output results as JSON
`--quiet`, `-q`	Minimal output, only results

Examples

 1# Count rows in a table
 2node .claude/skills/clickhouse-query/query.mjs "SELECT count() FROM views"
 3
 4# Query with filters
 5node .claude/skills/clickhouse-query/query.mjs "SELECT * FROM modelEvents WHERE modelId = 123 LIMIT 10"
 6
 7# Check query execution plan
 8node .claude/skills/clickhouse-query/query.mjs --explain "SELECT * FROM views WHERE userId = 1"
 9
10# Override default 30s timeout for longer queries
11node .claude/skills/clickhouse-query/query.mjs --timeout 60 "SELECT ... (complex aggregation)"
12
13# Query from file
14node .claude/skills/clickhouse-query/query.mjs -f my-query.sql
15
16# JSON output for processing
17node .claude/skills/clickhouse-query/query.mjs --json "SELECT type, count() FROM modelEvents GROUP BY type"

Safety Features

Read-only by default: Blocks INSERT/ALTER/DROP unless --writable flag is used
30 second timeout: Prevents runaway queries (override with --timeout)
Explicit permission required: Before using --writable, you MUST ask the user for permission

When to Use –writable

Only use the --writable flag when:

Clickup

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

ClickUp

Interact with ClickUp tasks and documents via the API. Get task information, view comments, create tasks, manage assignments, post updates, and create/edit documents.

Setup

Copy .env-example to .env in this skill directory
Add your ClickUp Personal API Token (starts with pk_)
Generate token at: ClickUp Settings > Apps > API Token

1cp .claude/skills/clickup/.env-example .claude/skills/clickup/.env
2# Edit .env and add your token

Team ID and User ID are auto-detected and cached on first use.

Clojure Review

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

Clojure Code Review Skill

@./../_shared/clojure-style-guide.md @./../_shared/clojure-commands.md

Review guidelines

What to flag:

Check compliance with the Metabase Clojure style guide (included above)
If CLOJURE_STYLE_GUIDE.adoc exists in the working directory, also check compliance with the community Clojure style guide
Flag all style guide violations

What NOT to post:

Do not post comments congratulating someone for trivial changes or for following style guidelines
Do not post comments confirming things “look good” or telling them they did something correctly
Only post comments about style violations or potential issues

Example bad code review comments to avoid:

Clojure Write

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

Clojure Development Skill

Tool Preference

When clojure-mcp tools are available (e.g., clojure_eval, clojure_edit), always use them instead of shell commands like ./bin/mage -repl. The MCP tools provide:

Direct REPL integration without shell escaping issues
Better error messages and feedback
Structural Clojure editing that prevents syntax errors

Only fall back to ./bin/mage commands when clojure-mcp is not available.

@./../_shared/development-workflow.md @./../_shared/clojure-style-guide.md @./../_shared/clojure-commands.md

REPL-Driven Development Workflow

Start with small, fundamental functions:
Identify the core features or functionalities required for your task.
Break each feature down into the smallest, most basic functions that can be developed and tested independently.
Write and test in the REPL:
- Write the code for each small function directly in the REPL (Read-Eval-Print Loop).
- Test it thoroughly with a variety of inputs, including typical use cases and relevant edge cases, to ensure it behaves as expected.
Integrate into source code:
- Once a function works correctly in the REPL, move it from the REPL environment into your source code files (e.g., within appropriate namespaces).
Gradually increase complexity:
- Build upon tested, basic functions to create more complex functions or components.
- Compose smaller functions together, testing each new composition in the REPL to verify correctness step by step.
Ensure dependency testing:
- Make sure every function is fully tested in the REPL before it is depended upon by other functions.
- This ensures that each layer of your application is reliable before you build on it.
Use the REPL fully:
- Use the REPL as your primary tool to experiment with different approaches, iterate quickly, and get immediate feedback on your code.
Follow functional programming principles:
- Keep functions small, focused, and composable.
- Use Clojure’s functional programming features—like immutability, higher-order functions, and the standard library—to write concise, effective code.

How to Evaluate Code

Bottom-up Dev Loop

Write code into a file.
Evaluate the file’s namespace and make sure it loads correctly with:

./bin/mage -repl --namespace metabase.app-db.connection

Call functions in the namespace with test inputs, and observe that the outputs are correct Feel free to copy these REPL session trials into actual test cases using deftest and is.
Once you know these functions are good, return to 1, and compose them into the task that you need to build.

Critical Rules for Editing

Be careful with parentheses counts when editing Clojure code
After EVERY change to Clojure code, verify readability with -check-readable
End all files with a newline
When editing tabular code, where the columns line up, try to keep them aligned
Spaces on a line with nothing after it is not allowed

Cocoindex

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

CocoIndex

Overview

CocoIndex is an ultra-performant real-time data transformation framework for AI with incremental processing. This skill enables building indexing flows that extract data from sources, apply transformations (chunking, embedding, LLM extraction), and export to targets (vector databases, graph databases, relational databases).

Core capabilities:

Write indexing flows - Define ETL pipelines using Python
Create custom functions - Build reusable transformation logic
Operate flows - Run and manage flows using CLI or Python API

Key features:

Code Review

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

Code Review Skill

You now have expertise in conducting comprehensive code reviews. Follow this structured approach:

Review Checklist

1. Security (Critical)

Check for:

Injection vulnerabilities: SQL, command, XSS, template injection
Authentication issues: Hardcoded credentials, weak auth
Authorization flaws: Missing access controls, IDOR
Data exposure: Sensitive data in logs, error messages
Cryptography: Weak algorithms, improper key management
Dependencies: Known vulnerabilities (check with npm audit, pip-audit)

1# Quick security scans
2npm audit # Node.js
3pip-audit # Python
4cargo audit # Rust
5grep -r "password\|secret\|api_key" --include="*.py" --include="*.js"

2. Correctness

Check for:

Code Review Excellence

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

Code Review Excellence

Transform code reviews from gatekeeping to knowledge sharing through constructive feedback, systematic analysis, and collaborative improvement.

When to Use This Skill

Reviewing pull requests and code changes
Establishing code review standards for teams
Mentoring junior developers through reviews
Conducting architecture reviews
Creating review checklists and guidelines
Improving team collaboration
Reducing code review cycle time
Maintaining code quality standards

Core Principles

1. The Review Mindset

Goals of Code Review:

Code Reviewer

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

Code Reviewer

Complete toolkit for code reviewer with modern tools and best practices.

Quick Start

Main Capabilities

This skill provides three core capabilities through automated scripts:

1# Script 1: Pr Analyzer
2python scripts/pr_analyzer.py [options]
3
4# Script 2: Code Quality Checker
5python scripts/code_quality_checker.py [options]
6
7# Script 3: Review Report Generator
8python scripts/review_report_generator.py [options]

Core Capabilities

1. Pr Analyzer

Automated tool for pr analyzer tasks.

Command Development

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

Command Development for Claude Code

Overview

Slash commands are frequently-used prompts defined as Markdown files that Claude executes during interactive sessions. Understanding command structure, frontmatter options, and dynamic features enables creating powerful, reusable workflows.

Key concepts:

Markdown file format for commands
YAML frontmatter for configuration
Dynamic arguments and file references
Bash execution for context
Command organization and namespacing

Command Basics

What is a Slash Command?

A slash command is a Markdown file containing a prompt that Claude executes when invoked. Commands provide:

Command Name

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

Plugin Structure for Claude Code

Overview

Claude Code plugins follow a standardized directory structure with automatic component discovery. Understanding this structure enables creating well-organized, maintainable plugins that integrate seamlessly with Claude Code.

Key concepts:

Conventional directory layout for automatic discovery
Manifest-driven configuration in .claude-plugin/plugin.json
Component-based organization (commands, agents, skills, hooks)
Portable path references using ${CLAUDE_PLUGIN_ROOT}
Explicit vs. auto-discovered component loading

Directory Structure

Every Claude Code plugin follows this organizational pattern:

Commit Helper

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

CockroachDB Commit Helper

Help the user create properly formatted commit messages and release notes that follow CockroachDB conventions.

Workflow

Analyze the changes: Run git diff --staged or git diff to understand what was modified
Determine the package prefix: Identify the primary package affected
Ask the user for:
- Issue/epic number if not already known
- Whether release notes are needed and what category fits best
Write the subject line: Imperative mood, no period, under 72 characters
Write the body: Explain the before/after, why the change was needed
Add issue references: Include Resolves/Epic as appropriate
Write the release note: Clear, user-focused description of the change
Create the commit using the properly formatted message

Commit Message Structure

Basic Format:

Component Search

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

Redpanda Connect Component Search

Help users discover the right Redpanda Connect components for their streaming pipeline needs.

Objective

Find and recommend the most relevant components that match the user’s natural language query. Provide enough information for users to understand what each component does, how to configure it, and why it matches their needs.

Prerequisites

This skill requires: rpk, rpk connect, python3. See the SETUP for installation instructions.

Component Categories

Redpanda Connect has 8 types of components:

Configured Agent

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

Plugin Settings Pattern for Claude Code Plugins

Overview

Plugins can store user-configurable settings and state in .claude/plugin-name.local.md files within the project directory. This pattern uses YAML frontmatter for structured configuration and markdown content for prompts or additional context.

Key characteristics:

File location: .claude/plugin-name.local.md in project root
Structure: YAML frontmatter + markdown body
Purpose: Per-project plugin configuration and state
Usage: Read from hooks, commands, and agents
Lifecycle: User-managed (not in git, should be in .gitignore)

File Structure

Basic Template

 1---
 2enabled: true
 3setting1: value1
 4setting2: value2
 5numeric_setting: 42
 6list_setting: ["item1", "item2"]
 7---
 8
 9# Additional Context
10
11This markdown body can contain:
12- Task descriptions
13- Additional instructions
14- Prompts to feed back to Claude
15- Documentation or notes

Example: Plugin State File

.claude/my-plugin.local.md:

Connect

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

Connect

Connect Claude to any app. Stop generating text about what you could do - actually do it.

When to Use This Skill

Use this skill when you need Claude to:

Send that email instead of drafting it
Create that issue instead of describing it
Post that message instead of suggesting it
Update that database instead of explaining how

What Changes

Without Connect	With Connect
“Here’s a draft email…”	Sends the email
“You should create an issue…”	Creates the issue
“Post this to Slack…”	Posts it
“Add this to Notion…”	Adds it

Supported Apps

1000+ integrations including:

Connect Apps - 将Claude连接到1000+服务

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

Connect Apps

Connect Claude to 1000+ apps. Actually send emails, create issues, post messages - not just generate text about it.

Quick Start

Step 1: Install the Plugin

/plugin install composio-toolrouter

Step 2: Run Setup

/composio-toolrouter:setup

This will:

Ask for your free API key (get one at platform.composio.dev)
Configure Claude’s connection to 1000+ apps
Take about 60 seconds

Step 3: Try It!

After setup, restart Claude Code and try:

Send me a test email at YOUR_EMAIL@example.com

If it works, you’re connected!

Cookbook Audit

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

Cookbook Audit

Instructions

Review the requested Cookbook notebook using the guidelines and rubrics in style_guide.md. Provide a score based on scoring guidelines and recommendations on improving the cookbook.

The style guide provides detailed templates and examples for:

Problem-focused introductions with Terminal Learning Objectives (TLOs) and Enabling Learning Objectives (ELOs)
Prerequisites and setup patterns
Core content structure
Conclusions that map back to learning objectives

IMPORTANT: Always read style_guide.md first before conducting an audit. The style guide contains the canonical templates and good/bad examples to reference.

Copilot

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

Examples

1# Create a task with an inline description
2gh agent-task create "<task description>"
3
4# Create a task from a markdown file
5gh agent-task create -F task-desc.md

Cqrs Implementation

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

CQRS Implementation

Comprehensive guide to implementing CQRS (Command Query Responsibility Segregation) patterns.

When to Use This Skill

Separating read and write concerns
Scaling reads independently from writes
Building event-sourced systems
Optimizing complex query scenarios
Different read/write data models needed
High-performance reporting requirements

Core Concepts

1. CQRS Architecture

 ┌─────────────┐
 │ Client │
 └──────┬──────┘
 │
 ┌────────────┴────────────┐
 │ │
 ▼ ▼
 ┌─────────────┐ ┌─────────────┐
 │ Commands │ │ Queries │
 │ API │ │ API │
 └──────┬──────┘ └──────┬──────┘
 │ │
 ▼ ▼
 ┌─────────────┐ ┌─────────────┐
 │ Command │ │ Query │
 │ Handlers │ │ Handlers │
 └──────┬──────┘ └──────┬──────┘
 │ │
 ▼ ▼
 ┌─────────────┐ ┌─────────────┐
 │ Write │─────────►│ Read │
 │ Model │ Events │ Model │
 └─────────────┘ └─────────────┘

2. Key Components

Component	Responsibility
Command	Intent to change state
Command Handler	Validates and executes commands
Event	Record of state change
Query	Request for data
Query Handler	Retrieves data from read model
Projector	Updates read model from events

Templates

Template 1: Command Infrastructure

 1from abc import ABC, abstractmethod
 2from dataclasses import dataclass
 3from typing import TypeVar, Generic, Dict, Any, Type
 4from datetime import datetime
 5import uuid
 6
 7# Command base
 8@dataclass
 9class Command:
10 command_id: str = None
11 timestamp: datetime = None
12
13 def __post_init__(self):
14 self.command_id = self.command_id or str(uuid.uuid4())
15 self.timestamp = self.timestamp or datetime.utcnow()
16
17
18# Concrete commands
19@dataclass
20class CreateOrder(Command):
21 customer_id: str
22 items: list
23 shipping_address: dict
24
25
26@dataclass
27class AddOrderItem(Command):
28 order_id: str
29 product_id: str
30 quantity: int
31 price: float
32
33
34@dataclass
35class CancelOrder(Command):
36 order_id: str
37 reason: str
38
39
40# Command handler base
41T = TypeVar('T', bound=Command)
42
43class CommandHandler(ABC, Generic[T]):
44 @abstractmethod
45 async def handle(self, command: T) -> Any:
46 pass
47
48
49# Command bus
50class CommandBus:
51 def __init__(self):
52 self._handlers: Dict[Type[Command], CommandHandler] = {}
53
54 def register(self, command_type: Type[Command], handler: CommandHandler):
55 self._handlers[command_type] = handler
56
57 async def dispatch(self, command: Command) -> Any:
58 handler = self._handlers.get(type(command))
59 if not handler:
60 raise ValueError(f"No handler for {type(command).__name__}")
61 return await handler.handle(command)
62
63
64# Command handler implementation
65class CreateOrderHandler(CommandHandler[CreateOrder]):
66 def __init__(self, order_repository, event_store):
67 self.order_repository = order_repository
68 self.event_store = event_store
69
70 async def handle(self, command: CreateOrder) -> str:
71 # Validate
72 if not command.items:
73 raise ValueError("Order must have at least one item")
74
75 # Create aggregate
76 order = Order.create(
77 customer_id=command.customer_id,
78 items=command.items,
79 shipping_address=command.shipping_address
80 )
81
82 # Persist events
83 await self.event_store.append_events(
84 stream_id=f"Order-{order.id}",
85 stream_type="Order",
86 events=order.uncommitted_events
87 )
88
89 return order.id

Template 2: Query Infrastructure

 1from abc import ABC, abstractmethod
 2from dataclasses import dataclass
 3from typing import TypeVar, Generic, List, Optional
 4
 5# Query base
 6@dataclass
 7class Query:
 8 pass
 9
 10
 11# Concrete queries
 12@dataclass
 13class GetOrderById(Query):
 14 order_id: str
 15
 16
 17@dataclass
 18class GetCustomerOrders(Query):
 19 customer_id: str
 20 status: Optional[str] = None
 21 page: int = 1
 22 page_size: int = 20
 23
 24
 25@dataclass
 26class SearchOrders(Query):
 27 query: str
 28 filters: dict = None
 29 sort_by: str = "created_at"
 30 sort_order: str = "desc"
 31
 32
 33# Query result types
 34@dataclass
 35class OrderView:
 36 order_id: str
 37 customer_id: str
 38 status: str
 39 total_amount: float
 40 item_count: int
 41 created_at: datetime
 42 shipped_at: Optional[datetime] = None
 43
 44
 45@dataclass
 46class PaginatedResult(Generic[T]):
 47 items: List[T]
 48 total: int
 49 page: int
 50 page_size: int
 51
 52 @property
 53 def total_pages(self) -> int:
 54 return (self.total + self.page_size - 1) // self.page_size
 55
 56
 57# Query handler base
 58T = TypeVar('T', bound=Query)
 59R = TypeVar('R')
 60
 61class QueryHandler(ABC, Generic[T, R]):
 62 @abstractmethod
 63 async def handle(self, query: T) -> R:
 64 pass
 65
 66
 67# Query bus
 68class QueryBus:
 69 def __init__(self):
 70 self._handlers: Dict[Type[Query], QueryHandler] = {}
 71
 72 def register(self, query_type: Type[Query], handler: QueryHandler):
 73 self._handlers[query_type] = handler
 74
 75 async def dispatch(self, query: Query) -> Any:
 76 handler = self._handlers.get(type(query))
 77 if not handler:
 78 raise ValueError(f"No handler for {type(query).__name__}")
 79 return await handler.handle(query)
 80
 81
 82# Query handler implementation
 83class GetOrderByIdHandler(QueryHandler[GetOrderById, Optional[OrderView]]):
 84 def __init__(self, read_db):
 85 self.read_db = read_db
 86
 87 async def handle(self, query: GetOrderById) -> Optional[OrderView]:
 88 async with self.read_db.acquire() as conn:
 89 row = await conn.fetchrow(
 90 """
 91 SELECT order_id, customer_id, status, total_amount,
 92 item_count, created_at, shipped_at
 93 FROM order_views
 94 WHERE order_id = $1
 95 """,
 96 query.order_id
 97 )
 98 if row:
 99 return OrderView(**dict(row))
100 return None
101
102
103class GetCustomerOrdersHandler(QueryHandler[GetCustomerOrders, PaginatedResult[OrderView]]):
104 def __init__(self, read_db):
105 self.read_db = read_db
106
107 async def handle(self, query: GetCustomerOrders) -> PaginatedResult[OrderView]:
108 async with self.read_db.acquire() as conn:
109 # Build query with optional status filter
110 where_clause = "customer_id = $1"
111 params = [query.customer_id]
112
113 if query.status:
114 where_clause += " AND status = $2"
115 params.append(query.status)
116
117 # Get total count
118 total = await conn.fetchval(
119 f"SELECT COUNT(*) FROM order_views WHERE {where_clause}",
120 *params
121 )
122
123 # Get paginated results
124 offset = (query.page - 1) * query.page_size
125 rows = await conn.fetch(
126 f"""
127 SELECT order_id, customer_id, status, total_amount,
128 item_count, created_at, shipped_at
129 FROM order_views
130 WHERE {where_clause}
131 ORDER BY created_at DESC
132 LIMIT ${len(params) + 1} OFFSET ${len(params) + 2}
133 """,
134 *params, query.page_size, offset
135 )
136
137 return PaginatedResult(
138 items=[OrderView(**dict(row)) for row in rows],
139 total=total,
140 page=query.page,
141 page_size=query.page_size
142 )

Template 3: FastAPI CQRS Application

 1from fastapi import FastAPI, HTTPException, Depends
 2from pydantic import BaseModel
 3from typing import List, Optional
 4
 5app = FastAPI()
 6
 7# Request/Response models
 8class CreateOrderRequest(BaseModel):
 9 customer_id: str
 10 items: List[dict]
 11 shipping_address: dict
 12
 13
 14class OrderResponse(BaseModel):
 15 order_id: str
 16 customer_id: str
 17 status: str
 18 total_amount: float
 19 item_count: int
 20 created_at: datetime
 21
 22
 23# Dependency injection
 24def get_command_bus() -> CommandBus:
 25 return app.state.command_bus
 26
 27
 28def get_query_bus() -> QueryBus:
 29 return app.state.query_bus
 30
 31
 32# Command endpoints (POST, PUT, DELETE)
 33@app.post("/orders", response_model=dict)
 34async def create_order(
 35 request: CreateOrderRequest,
 36 command_bus: CommandBus = Depends(get_command_bus)
 37):
 38 command = CreateOrder(
 39 customer_id=request.customer_id,
 40 items=request.items,
 41 shipping_address=request.shipping_address
 42 )
 43 order_id = await command_bus.dispatch(command)
 44 return {"order_id": order_id}
 45
 46
 47@app.post("/orders/{order_id}/items")
 48async def add_item(
 49 order_id: str,
 50 product_id: str,
 51 quantity: int,
 52 price: float,
 53 command_bus: CommandBus = Depends(get_command_bus)
 54):
 55 command = AddOrderItem(
 56 order_id=order_id,
 57 product_id=product_id,
 58 quantity=quantity,
 59 price=price
 60 )
 61 await command_bus.dispatch(command)
 62 return {"status": "item_added"}
 63
 64
 65@app.delete("/orders/{order_id}")
 66async def cancel_order(
 67 order_id: str,
 68 reason: str,
 69 command_bus: CommandBus = Depends(get_command_bus)
 70):
 71 command = CancelOrder(order_id=order_id, reason=reason)
 72 await command_bus.dispatch(command)
 73 return {"status": "cancelled"}
 74
 75
 76# Query endpoints (GET)
 77@app.get("/orders/{order_id}", response_model=OrderResponse)
 78async def get_order(
 79 order_id: str,
 80 query_bus: QueryBus = Depends(get_query_bus)
 81):
 82 query = GetOrderById(order_id=order_id)
 83 result = await query_bus.dispatch(query)
 84 if not result:
 85 raise HTTPException(status_code=404, detail="Order not found")
 86 return result
 87
 88
 89@app.get("/customers/{customer_id}/orders")
 90async def get_customer_orders(
 91 customer_id: str,
 92 status: Optional[str] = None,
 93 page: int = 1,
 94 page_size: int = 20,
 95 query_bus: QueryBus = Depends(get_query_bus)
 96):
 97 query = GetCustomerOrders(
 98 customer_id=customer_id,
 99 status=status,
100 page=page,
101 page_size=page_size
102 )
103 return await query_bus.dispatch(query)
104
105
106@app.get("/orders/search")
107async def search_orders(
108 q: str,
109 sort_by: str = "created_at",
110 query_bus: QueryBus = Depends(get_query_bus)
111):
112 query = SearchOrders(query=q, sort_by=sort_by)
113 return await query_bus.dispatch(query)

Template 4: Read Model Synchronization

 1class ReadModelSynchronizer:
 2 """Keeps read models in sync with events."""
 3
 4 def __init__(self, event_store, read_db, projections: List[Projection]):
 5 self.event_store = event_store
 6 self.read_db = read_db
 7 self.projections = {p.name: p for p in projections}
 8
 9 async def run(self):
10 """Continuously sync read models."""
11 while True:
12 for name, projection in self.projections.items():
13 await self._sync_projection(projection)
14 await asyncio.sleep(0.1)
15
16 async def _sync_projection(self, projection: Projection):
17 checkpoint = await self._get_checkpoint(projection.name)
18
19 events = await self.event_store.read_all(
20 from_position=checkpoint,
21 limit=100
22 )
23
24 for event in events:
25 if event.event_type in projection.handles():
26 try:
27 await projection.apply(event)
28 except Exception as e:
29 # Log error, possibly retry or skip
30 logger.error(f"Projection error: {e}")
31 continue
32
33 await self._save_checkpoint(projection.name, event.global_position)
34
35 async def rebuild_projection(self, projection_name: str):
36 """Rebuild a projection from scratch."""
37 projection = self.projections[projection_name]
38
39 # Clear existing data
40 await projection.clear()
41
42 # Reset checkpoint
43 await self._save_checkpoint(projection_name, 0)
44
45 # Rebuild
46 while True:
47 checkpoint = await self._get_checkpoint(projection_name)
48 events = await self.event_store.read_all(checkpoint, 1000)
49
50 if not events:
51 break
52
53 for event in events:
54 if event.event_type in projection.handles():
55 await projection.apply(event)
56
57 await self._save_checkpoint(
58 projection_name,
59 events[-1].global_position
60 )

Template 5: Eventual Consistency Handling

 1class ConsistentQueryHandler:
 2 """Query handler that can wait for consistency."""
 3
 4 def __init__(self, read_db, event_store):
 5 self.read_db = read_db
 6 self.event_store = event_store
 7
 8 async def query_after_command(
 9 self,
10 query: Query,
11 expected_version: int,
12 stream_id: str,
13 timeout: float = 5.0
14 ):
15 """
16 Execute query, ensuring read model is at expected version.
17 Used for read-your-writes consistency.
18 """
19 start_time = time.time()
20
21 while time.time() - start_time < timeout:
22 # Check if read model is caught up
23 projection_version = await self._get_projection_version(stream_id)
24
25 if projection_version >= expected_version:
26 return await self.execute_query(query)
27
28 # Wait a bit and retry
29 await asyncio.sleep(0.1)
30
31 # Timeout - return stale data with warning
32 return {
33 "data": await self.execute_query(query),
34 "_warning": "Data may be stale"
35 }
36
37 async def _get_projection_version(self, stream_id: str) -> int:
38 """Get the last processed event version for a stream."""
39 async with self.read_db.acquire() as conn:
40 return await conn.fetchval(
41 "SELECT last_event_version FROM projection_state WHERE stream_id = $1",
42 stream_id
43 ) or 0

Best Practices

Do’s

Separate command and query models - Different needs
Use eventual consistency - Accept propagation delay
Validate in command handlers - Before state change
Denormalize read models - Optimize for queries
Version your events - For schema evolution

Don’ts

Don’t query in commands - Use only for writes
Don’t couple read/write schemas - Independent evolution
Don’t over-engineer - Start simple
Don’t ignore consistency SLAs - Define acceptable lag

Resources

Create Pull Request

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

Create Pull Request

This skill guides you through creating a well-structured GitHub pull request that follows project conventions and best practices.

Prerequisites Check

Before proceeding, verify the following:

1. Check if `gh` CLI is installed

1gh --version

If not installed, inform the user:

The GitHub CLI (gh) is required but not installed. Please install it:

macOS: brew install gh

Other: https://cli.github.com/

2. Check if authenticated with GitHub

1gh auth status

If not authenticated, guide the user to run gh auth login.

Create Scratch

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

What I do

I help you create new scratch files in the .agents/scratches/ directory. Each scratch file gets:

A unique three-word identifier (e.g., calm-teal-cloud)
Frontmatter with the current date and formatted title
Content you provide

How to use

Run the script with a slug and content:

1npx tsx scripts/create-scratch.ts "note-name" "Scratch content here"

Or use heredoc for multi-line content:

1npx tsx scripts/create-scratch.ts "note-name" << HEREDOC
2Multi-line
3scratch content
4goes here
5HEREDOC

File format

Files are created as: {three-word-id}-{slug}.md

Crewai Multi Agent

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

CrewAI - Multi-Agent Orchestration Framework

Build teams of autonomous AI agents that collaborate to solve complex tasks.

When to use CrewAI

Use CrewAI when:

Building multi-agent systems with specialized roles
Need autonomous collaboration between agents
Want role-based task delegation (researcher, writer, analyst)
Require sequential or hierarchical process execution
Building production workflows with memory and observability
Need simpler setup than LangChain/LangGraph

Key features:

Standalone: No LangChain dependencies, lean footprint
Role-based: Agents have roles, goals, and backstories
Dual paradigm: Crews (autonomous) + Flows (event-driven)
50+ tools: Web scraping, search, databases, AI services
Memory: Short-term, long-term, and entity memory
Production-ready: Tracing, enterprise features

Use alternatives instead:

Cto Advisor

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

CTO Advisor

Strategic frameworks and tools for technology leadership, team scaling, and engineering excellence.

Keywords

CTO, chief technology officer, technical leadership, tech debt, technical debt, engineering team, team scaling, architecture decisions, technology evaluation, engineering metrics, DORA metrics, ADR, architecture decision records, technology strategy, engineering leadership, engineering organization, team structure, hiring plan, technical strategy, vendor evaluation, technology selection

Quick Start

For Technical Debt Assessment

1python scripts/tech_debt_analyzer.py

Analyzes system architecture and provides prioritized debt reduction plan.

Dashboard Create Screen

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

Dashboard Create Screen Skill

Creates new screens in client/dashboard with automatic route discovery and registration.

Step 1: Discover Available Routes

First, find all router files and extract available routes.

Find Router Files

Use Glob to discover router files:

client/dashboard/app/router/*.tsx
client/dashboard/app/router/*.ts

Extract Routes from Each File

For each router file, use Grep to extract route information.

Find exported route constants:

export\s+const\s+(\w+Route)\s*=\s*createRoute

Extract parent relationships:

getParentRoute:\s*\(\)\s*=>\s*(\w+Route)

Extract path segments:

path:\s*['"]([^'"]+)['"]

Extract component import paths:

Dbt Transformation Patterns

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

dbt Transformation Patterns

Production-ready patterns for dbt (data build tool) including model organization, testing strategies, documentation, and incremental processing.

When to Use This Skill

Building data transformation pipelines with dbt
Organizing models into staging, intermediate, and marts layers
Implementing data quality tests
Creating incremental models for large datasets
Documenting data models and lineage
Setting up dbt project structure

Core Concepts

1. Model Layers (Medallion Architecture)

sources/ Raw data definitions
 ↓
staging/ 1:1 with source, light cleaning
 ↓
intermediate/ Business logic, joins, aggregations
 ↓
marts/ Final analytics tables

2. Naming Conventions

Layer	Prefix	Example
Staging	`stg_`	`stg_stripe__payments`
Intermediate	`int_`	`int_payments_pivoted`
Marts	`dim_`, `fct_`	`dim_customers`, `fct_orders`

Quick Start

 1# dbt_project.yml
 2name: "analytics"
 3version: "1.0.0"
 4profile: "analytics"
 5
 6model-paths: ["models"]
 7analysis-paths: ["analyses"]
 8test-paths: ["tests"]
 9seed-paths: ["seeds"]
10macro-paths: ["macros"]
11
12vars:
13 start_date: "2020-01-01"
14
15models:
16 analytics:
17 staging:
18 +materialized: view
19 +schema: staging
20 intermediate:
21 +materialized: ephemeral
22 marts:
23 +materialized: table
24 +schema: analytics

# Project structure
models/
├── staging/
│ ├── stripe/
│ │ ├── _stripe__sources.yml
│ │ ├── _stripe__models.yml
│ │ ├── stg_stripe__customers.sql
│ │ └── stg_stripe__payments.sql
│ └── shopify/
│ ├── _shopify__sources.yml
│ └── stg_shopify__orders.sql
├── intermediate/
│ └── finance/
│ └── int_payments_pivoted.sql
└── marts/
 ├── core/
 │ ├── _core__models.yml
 │ ├── dim_customers.sql
 │ └── fct_orders.sql
 └── finance/
 └── fct_revenue.sql

Patterns

Pattern 1: Source Definitions

 1# models/staging/stripe/_stripe__sources.yml
 2version: 2
 3
 4sources:
 5 - name: stripe
 6 description: Raw Stripe data loaded via Fivetran
 7 database: raw
 8 schema: stripe
 9 loader: fivetran
10 loaded_at_field: _fivetran_synced
11 freshness:
12 warn_after: { count: 12, period: hour }
13 error_after: { count: 24, period: hour }
14 tables:
15 - name: customers
16 description: Stripe customer records
17 columns:
18 - name: id
19 description: Primary key
20 tests:
21 - unique
22 - not_null
23 - name: email
24 description: Customer email
25 - name: created
26 description: Account creation timestamp
27
28 - name: payments
29 description: Stripe payment transactions
30 columns:
31 - name: id
32 tests:
33 - unique
34 - not_null
35 - name: customer_id
36 tests:
37 - not_null
38 - relationships:
39 to: source('stripe', 'customers')
40 field: id

Pattern 2: Staging Models

 1-- models/staging/stripe/stg_stripe__customers.sql
 2with source as (
 3 select * from {{ source('stripe', 'customers') }}
 4),
 5
 6renamed as (
 7 select
 8 -- ids
 9 id as customer_id,
10
11 -- strings
12 lower(email) as email,
13 name as customer_name,
14
15 -- timestamps
16 created as created_at,
17
18 -- metadata
19 _fivetran_synced as _loaded_at
20
21 from source
22)
23
24select * from renamed

 1-- models/staging/stripe/stg_stripe__payments.sql
 2{{
 3 config(
 4 materialized='incremental',
 5 unique_key='payment_id',
 6 on_schema_change='append_new_columns'
 7 )
 8}}
 9
10with source as (
11 select * from {{ source('stripe', 'payments') }}
12
13 {% if is_incremental() %}
14 where _fivetran_synced > (select max(_loaded_at) from {{ this }})
15 {% endif %}
16),
17
18renamed as (
19 select
20 -- ids
21 id as payment_id,
22 customer_id,
23 invoice_id,
24
25 -- amounts (convert cents to dollars)
26 amount / 100.0 as amount,
27 amount_refunded / 100.0 as amount_refunded,
28
29 -- status
30 status as payment_status,
31
32 -- timestamps
33 created as created_at,
34
35 -- metadata
36 _fivetran_synced as _loaded_at
37
38 from source
39)
40
41select * from renamed

Pattern 3: Intermediate Models

 1-- models/intermediate/finance/int_payments_pivoted_to_customer.sql
 2with payments as (
 3 select * from {{ ref('stg_stripe__payments') }}
 4),
 5
 6customers as (
 7 select * from {{ ref('stg_stripe__customers') }}
 8),
 9
10payment_summary as (
11 select
12 customer_id,
13 count(*) as total_payments,
14 count(case when payment_status = 'succeeded' then 1 end) as successful_payments,
15 sum(case when payment_status = 'succeeded' then amount else 0 end) as total_amount_paid,
16 min(created_at) as first_payment_at,
17 max(created_at) as last_payment_at
18 from payments
19 group by customer_id
20)
21
22select
23 customers.customer_id,
24 customers.email,
25 customers.created_at as customer_created_at,
26 coalesce(payment_summary.total_payments, 0) as total_payments,
27 coalesce(payment_summary.successful_payments, 0) as successful_payments,
28 coalesce(payment_summary.total_amount_paid, 0) as lifetime_value,
29 payment_summary.first_payment_at,
30 payment_summary.last_payment_at
31
32from customers
33left join payment_summary using (customer_id)

Pattern 4: Mart Models (Dimensions and Facts)

 1-- models/marts/core/dim_customers.sql
 2{{
 3 config(
 4 materialized='table',
 5 unique_key='customer_id'
 6 )
 7}}
 8
 9with customers as (
10 select * from {{ ref('int_payments_pivoted_to_customer') }}
11),
12
13orders as (
14 select * from {{ ref('stg_shopify__orders') }}
15),
16
17order_summary as (
18 select
19 customer_id,
20 count(*) as total_orders,
21 sum(total_price) as total_order_value,
22 min(created_at) as first_order_at,
23 max(created_at) as last_order_at
24 from orders
25 group by customer_id
26),
27
28final as (
29 select
30 -- surrogate key
31 {{ dbt_utils.generate_surrogate_key(['customers.customer_id']) }} as customer_key,
32
33 -- natural key
34 customers.customer_id,
35
36 -- attributes
37 customers.email,
38 customers.customer_created_at,
39
40 -- payment metrics
41 customers.total_payments,
42 customers.successful_payments,
43 customers.lifetime_value,
44 customers.first_payment_at,
45 customers.last_payment_at,
46
47 -- order metrics
48 coalesce(order_summary.total_orders, 0) as total_orders,
49 coalesce(order_summary.total_order_value, 0) as total_order_value,
50 order_summary.first_order_at,
51 order_summary.last_order_at,
52
53 -- calculated fields
54 case
55 when customers.lifetime_value >= 1000 then 'high'
56 when customers.lifetime_value >= 100 then 'medium'
57 else 'low'
58 end as customer_tier,
59
60 -- timestamps
61 current_timestamp as _loaded_at
62
63 from customers
64 left join order_summary using (customer_id)
65)
66
67select * from final

 1-- models/marts/core/fct_orders.sql
 2{{
 3 config(
 4 materialized='incremental',
 5 unique_key='order_id',
 6 incremental_strategy='merge'
 7 )
 8}}
 9
10with orders as (
11 select * from {{ ref('stg_shopify__orders') }}
12
13 {% if is_incremental() %}
14 where updated_at > (select max(updated_at) from {{ this }})
15 {% endif %}
16),
17
18customers as (
19 select * from {{ ref('dim_customers') }}
20),
21
22final as (
23 select
24 -- keys
25 orders.order_id,
26 customers.customer_key,
27 orders.customer_id,
28
29 -- dimensions
30 orders.order_status,
31 orders.fulfillment_status,
32 orders.payment_status,
33
34 -- measures
35 orders.subtotal,
36 orders.tax,
37 orders.shipping,
38 orders.total_price,
39 orders.total_discount,
40 orders.item_count,
41
42 -- timestamps
43 orders.created_at,
44 orders.updated_at,
45 orders.fulfilled_at,
46
47 -- metadata
48 current_timestamp as _loaded_at
49
50 from orders
51 left join customers on orders.customer_id = customers.customer_id
52)
53
54select * from final

Pattern 5: Testing and Documentation

 1# models/marts/core/_core__models.yml
 2version: 2
 3
 4models:
 5 - name: dim_customers
 6 description: Customer dimension with payment and order metrics
 7 columns:
 8 - name: customer_key
 9 description: Surrogate key for the customer dimension
10 tests:
11 - unique
12 - not_null
13
14 - name: customer_id
15 description: Natural key from source system
16 tests:
17 - unique
18 - not_null
19
20 - name: email
21 description: Customer email address
22 tests:
23 - not_null
24
25 - name: customer_tier
26 description: Customer value tier based on lifetime value
27 tests:
28 - accepted_values:
29 values: ["high", "medium", "low"]
30
31 - name: lifetime_value
32 description: Total amount paid by customer
33 tests:
34 - dbt_utils.expression_is_true:
35 expression: ">= 0"
36
37 - name: fct_orders
38 description: Order fact table with all order transactions
39 tests:
40 - dbt_utils.recency:
41 datepart: day
42 field: created_at
43 interval: 1
44 columns:
45 - name: order_id
46 tests:
47 - unique
48 - not_null
49 - name: customer_key
50 tests:
51 - not_null
52 - relationships:
53 to: ref('dim_customers')
54 field: customer_key

Pattern 6: Macros and DRY Code

 1-- macros/cents_to_dollars.sql
 2{% macro cents_to_dollars(column_name, precision=2) %}
 3 round({{ column_name }} / 100.0, {{ precision }})
 4{% endmacro %}
 5
 6-- macros/generate_schema_name.sql
 7{% macro generate_schema_name(custom_schema_name, node) %}
 8 {%- set default_schema = target.schema -%}
 9 {%- if custom_schema_name is none -%}
10 {{ default_schema }}
11 {%- else -%}
12 {{ default_schema }}_{{ custom_schema_name }}
13 {%- endif -%}
14{% endmacro %}
15
16-- macros/limit_data_in_dev.sql
17{% macro limit_data_in_dev(column_name, days=3) %}
18 {% if target.name == 'dev' %}
19 where {{ column_name }} >= dateadd(day, -{{ days }}, current_date)
20 {% endif %}
21{% endmacro %}
22
23-- Usage in model
24select * from {{ ref('stg_orders') }}
25{{ limit_data_in_dev('created_at') }}

Pattern 7: Incremental Strategies

 1-- Delete+Insert (default for most warehouses)
 2{{
 3 config(
 4 materialized='incremental',
 5 unique_key='id',
 6 incremental_strategy='delete+insert'
 7 )
 8}}
 9
10-- Merge (best for late-arriving data)
11{{
12 config(
13 materialized='incremental',
14 unique_key='id',
15 incremental_strategy='merge',
16 merge_update_columns=['status', 'amount', 'updated_at']
17 )
18}}
19
20-- Insert Overwrite (partition-based)
21{{
22 config(
23 materialized='incremental',
24 incremental_strategy='insert_overwrite',
25 partition_by={
26 "field": "created_date",
27 "data_type": "date",
28 "granularity": "day"
29 }
30 )
31}}
32
33select
34 *,
35 date(created_at) as created_date
36from {{ ref('stg_events') }}
37
38{% if is_incremental() %}
39where created_date >= dateadd(day, -3, current_date)
40{% endif %}

dbt Commands

 1# Development
 2dbt run # Run all models
 3dbt run --select staging # Run staging models only
 4dbt run --select +fct_orders # Run fct_orders and its upstream
 5dbt run --select fct_orders+ # Run fct_orders and its downstream
 6dbt run --full-refresh # Rebuild incremental models
 7
 8# Testing
 9dbt test # Run all tests
10dbt test --select stg_stripe # Test specific models
11dbt build # Run + test in DAG order
12
13# Documentation
14dbt docs generate # Generate docs
15dbt docs serve # Serve docs locally
16
17# Debugging
18dbt compile # Compile SQL without running
19dbt debug # Test connection
20dbt ls --select tag:critical # List models by tag

Best Practices

Do’s

Use staging layer - Clean data once, use everywhere
Test aggressively - Not null, unique, relationships
Document everything - Column descriptions, model descriptions
Use incremental - For tables > 1M rows
Version control - dbt project in Git

Don’ts

Don’t skip staging - Raw → mart is tech debt
Don’t hardcode dates - Use {{ var('start_date') }}
Don’t repeat logic - Extract to macros
Don’t test in prod - Use dev target
Don’t ignore freshness - Monitor source data

Resources

Debug

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

Debug Mode

Fix bugs with runtime evidence, not guesses.

Don't guess → Hypothesize → Instrument → Reproduce → Analyze → Fix → Verify

When to Use

Trigger signals (if you’re about to do any of these, use this skill instead):

“Open DevTools Console and check for…”
“Reproduce the bug and tell me what you see”
“Add console.log and let me know the output”
“Click X, open Y, check if Z appears in console”

Example scenario that should trigger this skill:

Debugging Strategies

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

Debugging Strategies

Transform debugging from frustrating guesswork into systematic problem-solving with proven strategies, powerful tools, and methodical approaches.

When to Use This Skill

Tracking down elusive bugs
Investigating performance issues
Understanding unfamiliar codebases
Debugging production issues
Analyzing crash dumps and stack traces
Profiling application performance
Investigating memory leaks
Debugging distributed systems

Core Principles

1. The Scientific Method

1. Observe: What’s the actual behavior? 2. Hypothesize: What could be causing it? 3. Experiment: Test your hypothesis 4. Analyze: Did it prove/disprove your theory? 5. Repeat: Until you find the root cause

Deployment Pipeline Design

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

Deployment Pipeline Design

Architecture patterns for multi-stage CI/CD pipelines with approval gates and deployment strategies.

Purpose

Design robust, secure deployment pipelines that balance speed with safety through proper stage organization and approval workflows.

When to Use

Design CI/CD architecture
Implement deployment gates
Configure multi-environment pipelines
Establish deployment best practices
Implement progressive delivery

Pipeline Stages

Standard Pipeline Flow

┌─────────┐ ┌──────┐ ┌─────────┐ ┌────────┐ ┌──────────┐
│ Build │ → │ Test │ → │ Staging │ → │ Approve│ → │Production│
└─────────┘ └──────┘ └─────────┘ └────────┘ └──────────┘

Detailed Stage Breakdown

Source - Code checkout
Build - Compile, package, containerize
Test - Unit, integration, security scans
Staging Deploy - Deploy to staging environment
Integration Tests - E2E, smoke tests
Approval Gate - Manual approval required
Production Deploy - Canary, blue-green, rolling
Verification - Health checks, monitoring
Rollback - Automated rollback on failure

Approval Gate Patterns

Pattern 1: Manual Approval

 1# GitHub Actions
 2production-deploy:
 3 needs: staging-deploy
 4 environment:
 5 name: production
 6 url: https://app.example.com
 7 runs-on: ubuntu-latest
 8 steps:
 9 - name: Deploy to production
10 run: |
11 # Deployment commands

Pattern 2: Time-Based Approval

 1# GitLab CI
 2deploy:production:
 3 stage: deploy
 4 script:
 5 - deploy.sh production
 6 environment:
 7 name: production
 8 when: delayed
 9 start_in: 30 minutes
10 only:
11 - main

Pattern 3: Multi-Approver

 1# Azure Pipelines
 2stages:
 3 - stage: Production
 4 dependsOn: Staging
 5 jobs:
 6 - deployment: Deploy
 7 environment:
 8 name: production
 9 resourceType: Kubernetes
10 strategy:
11 runOnce:
12 preDeploy:
13 steps:
14 - task: ManualValidation@0
15 inputs:
16 notifyUsers: "team-leads@example.com"
17 instructions: "Review staging metrics before approving"

Reference: See assets/approval-gate-template.yml

Deslop

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

Remove AI Code Slop

Check the diff against main and remove all AI-generated slop introduced in this branch.

What to Remove

Extra comments that a human wouldn’t add or are inconsistent with the rest of the file
Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted/validated codepaths)
Casts to any to get around type issues
Inline imports in Python (move to top of file with other imports)
Any other style that is inconsistent with the file

Process

Get the diff against main: git diff main...HEAD
Review each changed file for slop patterns
Remove identified slop while preserving legitimate changes
Report a 1-3 sentence summary of what was changed

Developer Growth Analysis

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

Developer Growth Analysis

This skill provides personalized feedback on your recent coding work by analyzing your Claude Code chat interactions and identifying patterns that reveal strengths and areas for growth.

When to Use This Skill

Use this skill when you want to:

Understand your development patterns and habits from recent work
Identify specific technical gaps or recurring challenges
Discover which topics would benefit from deeper study
Get curated learning resources tailored to your actual work patterns
Track improvement areas across your recent projects
Find high-quality articles that directly address the skills you’re developing

This skill is ideal for developers who want structured feedback on their growth without waiting for code reviews, and who prefer data-driven insights from their own work history.

Dispatching Parallel Agents

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

Dispatching Parallel Agents

Overview

When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.

Core principle: Dispatch one agent per independent problem domain. Let them work concurrently.

When to Use

digraph when_to_use {
 "Multiple failures?" [shape=diamond];
 "Are they independent?" [shape=diamond];
 "Single agent investigates all" [shape=box];
 "One agent per problem domain" [shape=box];
 "Can they work in parallel?" [shape=diamond];
 "Sequential agents" [shape=box];
 "Parallel dispatch" [shape=box];

 "Multiple failures?" -> "Are they independent?" [label="yes"];
 "Are they independent?" -> "Single agent investigates all" [label="no - related"];
 "Are they independent?" -> "Can they work in parallel?" [label="yes"];
 "Can they work in parallel?" -> "Parallel dispatch" [label="yes"];
 "Can they work in parallel?" -> "Sequential agents" [label="no - shared state"];
}

Use when:

Distributed Tracing

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

Distributed Tracing

Implement distributed tracing with Jaeger and Tempo for request flow visibility across microservices.

Purpose

Track requests across distributed systems to understand latency, dependencies, and failure points.

When to Use

Debug latency issues
Understand service dependencies
Identify bottlenecks
Trace error propagation
Analyze request paths

Distributed Tracing Concepts

Trace Structure

Trace (Request ID: abc123)
 ↓
Span (frontend) [100ms]
 ↓
Span (api-gateway) [80ms]
 ├→ Span (auth-service) [10ms]
 └→ Span (user-service) [60ms]
 └→ Span (database) [40ms]

Key Components

Trace - End-to-end request journey
Span - Single operation within a trace
Context - Metadata propagated between services
Tags - Key-value pairs for filtering
Logs - Timestamped events within a span

Jaeger Setup

Kubernetes Deployment

 1# Deploy Jaeger Operator
 2kubectl create namespace observability
 3kubectl create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v1.51.0/jaeger-operator.yaml -n observability
 4
 5# Deploy Jaeger instance
 6kubectl apply -f - <<EOF
 7apiVersion: jaegertracing.io/v1
 8kind: Jaeger
 9metadata:
10 name: jaeger
11 namespace: observability
12spec:
13 strategy: production
14 storage:
15 type: elasticsearch
16 options:
17 es:
18 server-urls: http://elasticsearch:9200
19 ingress:
20 enabled: true
21EOF

Docker Compose

 1version: "3.8"
 2services:
 3 jaeger:
 4 image: jaegertracing/all-in-one:latest
 5 ports:
 6 - "5775:5775/udp"
 7 - "6831:6831/udp"
 8 - "6832:6832/udp"
 9 - "5778:5778"
10 - "16686:16686" # UI
11 - "14268:14268" # Collector
12 - "14250:14250" # gRPC
13 - "9411:9411" # Zipkin
14 environment:
15 - COLLECTOR_ZIPKIN_HOST_PORT=:9411

Reference: See references/jaeger-setup.md

Dnanexus Integration

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

DNAnexus Integration

Overview

DNAnexus is a cloud platform for biomedical data analysis and genomics. Build and deploy apps/applets, manage data objects, run workflows, and use the dxpy Python SDK for genomics pipeline development and execution.

When to Use This Skill

This skill should be used when:

Creating, building, or modifying DNAnexus apps/applets
Uploading, downloading, searching, or organizing files and records
Running analyses, monitoring jobs, creating workflows
Writing scripts using dxpy to interact with the platform
Setting up dxapp.json, managing dependencies, using Docker
Processing FASTQ, BAM, VCF, or other bioinformatics files
Managing projects, permissions, or platform resources

Core Capabilities

The skill is organized into five main areas, each with detailed reference documentation:

Doc Coauthoring

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

Doc Co-Authoring Workflow

This skill provides a structured workflow for guiding users through collaborative document creation. Act as an active guide, walking users through three stages: Context Gathering, Refinement & Structure, and Reader Testing.

When to Offer This Workflow

Trigger conditions:

User mentions writing documentation: “write a doc”, “draft a proposal”, “create a spec”, “write up”
User mentions specific doc types: “PRD”, “design doc”, “decision doc”, “RFC”
User seems to be starting a substantial writing task

Initial offer: Offer the user a structured workflow for co-authoring the document. Explain the three stages:

Doc Sync

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

Doc Sync Skill

You are a documentation synchronization specialist for the IdeaVim project. Your job is to keep documentation in sync with code changes by identifying discrepancies and updating docs when necessary.

Documentation Locations

The IdeaVim project has documentation in these locations:

doc/ folder - Detailed documentation files
README.md - Main project README
CONTRIBUTING.md - Contribution guidelines

Core Mindset

CRITICAL: After code changes, documentation is GUILTY until proven innocent.

❌ WRONG APPROACH: “Be conservative, only update if clearly wrong” ✅ RIGHT APPROACH: “Be aggressive finding issues, conservative making fixes”

Docs Review

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

Documentation Review Skill

@./../_shared/metabase-style-guide.md

Review mode detection

IMPORTANT: Before starting the review, determine which mode to use:

PR review mode: If the mcp__github__create_pending_pull_request_review tool is available, you are reviewing a GitHub PR
- Use the pending review workflow to post all issues as one cohesive review
- Follow the workflow steps in “PR review mode format” below
Local review mode: If the MCP tool is NOT available, output issues in the conversation

Docs Sync

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

Docs Sync

Overview

Identify doc coverage gaps and inaccuracies by comparing main branch features and configuration options against the current docs structure, then propose targeted improvements.

Workflow

Confirm scope and base branch
- Identify the current branch and default branch (usually main).
- Prefer analyzing the current branch to keep work aligned with in-flight changes.
- If the current branch is not main, analyze only the diff vs main to scope doc updates.
- Avoid switching branches if it would disrupt local changes; use git show main:<path> or git worktree add when needed.
Build a feature inventory from the selected scope

Docs Write

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

Documentation Writing Skill

@./../_shared/metabase-style-guide.md

When writing documentation

Start here

Who is this for? Match complexity to audience. Don’t oversimplify hard things or overcomplicate simple ones.
What do they need? Get them to the answer fast. Nobody wants to be in docs longer than necessary.
What did you struggle with? Those common questions you had when learning? Answer them (without literally including the question).

Writing process

Draft:

Write out the steps/explanation as you’d tell a colleague
Lead with what to do, then explain why
Use headings that state your point: “Set SAML before adding users” not “SAML configuration timing”

Edit:

Documentation Lookup

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

When the user asks about libraries, frameworks, or needs code examples, use Context7 to fetch current documentation instead of relying on training data.

When to Use This Skill

Activate this skill when the user:

Asks setup or configuration questions (“How do I configure Next.js middleware?”)
Requests code involving libraries (“Write a Prisma query for…”)
Needs API references (“What are the Supabase auth methods?”)
Mentions specific frameworks (React, Vue, Svelte, Express, Tailwind, etc.)

How to Fetch Documentation

Step 1: Resolve the Library ID

Call resolve-library-id with:

Docx - 专业Word文档编辑器

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

DOCX creation, editing, and analysis

Overview

A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.

Workflow Decision Tree

Reading/Analyzing Content

Use “Text extraction” or “Raw XML access” sections below

Creating New Document

Use “Creating a new Word document” workflow

Domain Name Brainstormer

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

Domain Name Brainstormer

This skill helps you find the perfect domain name for your project by generating creative options and checking what’s actually available to register.

When to Use This Skill

Starting a new project or company
Launching a product or service
Creating a personal brand or portfolio site
Rebranding an existing project
Registering a domain for a side project
Finding available alternatives when your first choice is taken

What This Skill Does

Understands Your Project: Analyzes what you’re building and who it’s for
Generates Creative Names: Creates relevant, memorable domain options
Checks Availability: Verifies which domains are actually available across multiple TLDs
Multiple Extensions: Suggests .com, .io, .dev, .ai, .app, and more
Provides Alternatives: Offers variations if top choices are taken
Branding Insights: Explains why certain names work well

How to Use

Basic Brainstorming

I'm building a project management tool for remote teams. 
Suggest domain names.

Help me brainstorm domain names for a personal finance app

Specific Preferences

I need a domain name for my AI writing assistant. 
Prefer short names with .ai or .io extension.

With Keywords

Suggest domain names using the words "pixel" or "studio" 
for my design agency

Example

User: “I’m building a tool for developers to share code snippets. Suggest creative domain names.”

Dotnet Backend Patterns

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

.NET Backend Development Patterns

Master C#/.NET patterns for building production-grade APIs, MCP servers, and enterprise backends with modern best practices (2024/2025).

When to Use This Skill

Developing new .NET Web APIs or MCP servers
Reviewing C# code for quality and performance
Designing service architectures with dependency injection
Implementing caching strategies with Redis
Writing unit and integration tests
Optimizing database access with EF Core or Dapper
Configuring applications with IOptions pattern
Handling errors and implementing resilience patterns

Core Concepts

1. Project Structure (Clean Architecture)

src/
├── Domain/ # Core business logic (no dependencies)
│ ├── Entities/
│ ├── Interfaces/
│ ├── Exceptions/
│ └── ValueObjects/
├── Application/ # Use cases, DTOs, validation
│ ├── Services/
│ ├── DTOs/
│ ├── Validators/
│ └── Interfaces/
├── Infrastructure/ # External implementations
│ ├── Data/ # EF Core, Dapper repositories
│ ├── Caching/ # Redis, Memory cache
│ ├── External/ # HTTP clients, third-party APIs
│ └── DependencyInjection/ # Service registration
└── Api/ # Entry point
 ├── Controllers/ # Or MinimalAPI endpoints
 ├── Middleware/
 ├── Filters/
 └── Program.cs

2. Dependency Injection Patterns

 1// Service registration by lifetime
 2public static class ServiceCollectionExtensions
 3{
 4 public static IServiceCollection AddApplicationServices(
 5 this IServiceCollection services,
 6 IConfiguration configuration)
 7 {
 8 // Scoped: One instance per HTTP request
 9 services.AddScoped<IProductService, ProductService>();
10 services.AddScoped<IOrderService, OrderService>();
11
12 // Singleton: One instance for app lifetime
13 services.AddSingleton<ICacheService, RedisCacheService>();
14 services.AddSingleton<IConnectionMultiplexer>(_ =>
15 ConnectionMultiplexer.Connect(configuration["Redis:Connection"]!));
16
17 // Transient: New instance every time
18 services.AddTransient<IValidator<CreateOrderRequest>, CreateOrderValidator>();
19
20 // Options pattern for configuration
21 services.Configure<CatalogOptions>(configuration.GetSection("Catalog"));
22 services.Configure<RedisOptions>(configuration.GetSection("Redis"));
23
24 // Factory pattern for conditional creation
25 services.AddScoped<IPriceCalculator>(sp =>
26 {
27 var options = sp.GetRequiredService<IOptions<PricingOptions>>().Value;
28 return options.UseNewEngine
29 ? sp.GetRequiredService<NewPriceCalculator>()
30 : sp.GetRequiredService<LegacyPriceCalculator>();
31 });
32
33 // Keyed services (.NET 8+)
34 services.AddKeyedScoped<IPaymentProcessor, StripeProcessor>("stripe");
35 services.AddKeyedScoped<IPaymentProcessor, PayPalProcessor>("paypal");
36
37 return services;
38 }
39}
40
41// Usage with keyed services
42public class CheckoutService
43{
44 public CheckoutService(
45 [FromKeyedServices("stripe")] IPaymentProcessor stripeProcessor)
46 {
47 _processor = stripeProcessor;
48 }
49}

3. Async/Await Patterns

 1// ✅ CORRECT: Async all the way down
 2public async Task<Product> GetProductAsync(string id, CancellationToken ct = default)
 3{
 4 return await _repository.GetByIdAsync(id, ct);
 5}
 6
 7// ✅ CORRECT: Parallel execution with WhenAll
 8public async Task<(Stock, Price)> GetStockAndPriceAsync(
 9 string productId,
10 CancellationToken ct = default)
11{
12 var stockTask = _stockService.GetAsync(productId, ct);
13 var priceTask = _priceService.GetAsync(productId, ct);
14
15 await Task.WhenAll(stockTask, priceTask);
16
17 return (await stockTask, await priceTask);
18}
19
20// ✅ CORRECT: ConfigureAwait in libraries
21public async Task<T> LibraryMethodAsync<T>(CancellationToken ct = default)
22{
23 var result = await _httpClient.GetAsync(url, ct).ConfigureAwait(false);
24 return await result.Content.ReadFromJsonAsync<T>(ct).ConfigureAwait(false);
25}
26
27// ✅ CORRECT: ValueTask for hot paths with caching
28public ValueTask<Product?> GetCachedProductAsync(string id)
29{
30 if (_cache.TryGetValue(id, out Product? product))
31 return ValueTask.FromResult(product);
32
33 return new ValueTask<Product?>(GetFromDatabaseAsync(id));
34}
35
36// ❌ WRONG: Blocking on async (deadlock risk)
37var result = GetProductAsync(id).Result; // NEVER do this
38var result2 = GetProductAsync(id).GetAwaiter().GetResult(); // Also bad
39
40// ❌ WRONG: async void (except event handlers)
41public async void ProcessOrder() { } // Exceptions are lost
42
43// ❌ WRONG: Unnecessary Task.Run for already async code
44await Task.Run(async () => await GetDataAsync()); // Wastes thread

4. Configuration with IOptions

 1// Configuration classes
 2public class CatalogOptions
 3{
 4 public const string SectionName = "Catalog";
 5
 6 public int DefaultPageSize { get; set; } = 50;
 7 public int MaxPageSize { get; set; } = 200;
 8 public TimeSpan CacheDuration { get; set; } = TimeSpan.FromMinutes(15);
 9 public bool EnableEnrichment { get; set; } = true;
10}
11
12public class RedisOptions
13{
14 public const string SectionName = "Redis";
15
16 public string Connection { get; set; } = "localhost:6379";
17 public string KeyPrefix { get; set; } = "mcp:";
18 public int Database { get; set; } = 0;
19}
20
21// appsettings.json
22{
23 "Catalog": {
24 "DefaultPageSize": 50,
25 "MaxPageSize": 200,
26 "CacheDuration": "00:15:00",
27 "EnableEnrichment": true
28 },
29 "Redis": {
30 "Connection": "localhost:6379",
31 "KeyPrefix": "mcp:",
32 "Database": 0
33 }
34}
35
36// Registration
37services.Configure<CatalogOptions>(configuration.GetSection(CatalogOptions.SectionName));
38services.Configure<RedisOptions>(configuration.GetSection(RedisOptions.SectionName));
39
40// Usage with IOptions (singleton, read once at startup)
41public class CatalogService
42{
43 private readonly CatalogOptions _options;
44
45 public CatalogService(IOptions<CatalogOptions> options)
46 {
47 _options = options.Value;
48 }
49}
50
51// Usage with IOptionsSnapshot (scoped, re-reads on each request)
52public class DynamicService
53{
54 private readonly CatalogOptions _options;
55
56 public DynamicService(IOptionsSnapshot<CatalogOptions> options)
57 {
58 _options = options.Value; // Fresh value per request
59 }
60}
61
62// Usage with IOptionsMonitor (singleton, notified on changes)
63public class MonitoredService
64{
65 private CatalogOptions _options;
66
67 public MonitoredService(IOptionsMonitor<CatalogOptions> monitor)
68 {
69 _options = monitor.CurrentValue;
70 monitor.OnChange(newOptions => _options = newOptions);
71 }
72}

5. Result Pattern (Avoiding Exceptions for Flow Control)

 1// Generic Result type
 2public class Result<T>
 3{
 4 public bool IsSuccess { get; }
 5 public T? Value { get; }
 6 public string? Error { get; }
 7 public string? ErrorCode { get; }
 8
 9 private Result(bool isSuccess, T? value, string? error, string? errorCode)
10 {
11 IsSuccess = isSuccess;
12 Value = value;
13 Error = error;
14 ErrorCode = errorCode;
15 }
16
17 public static Result<T> Success(T value) => new(true, value, null, null);
18 public static Result<T> Failure(string error, string? code = null) => new(false, default, error, code);
19
20 public Result<TNew> Map<TNew>(Func<T, TNew> mapper) =>
21 IsSuccess ? Result<TNew>.Success(mapper(Value!)) : Result<TNew>.Failure(Error!, ErrorCode);
22
23 public async Task<Result<TNew>> MapAsync<TNew>(Func<T, Task<TNew>> mapper) =>
24 IsSuccess ? Result<TNew>.Success(await mapper(Value!)) : Result<TNew>.Failure(Error!, ErrorCode);
25}
26
27// Usage in service
28public async Task<Result<Order>> CreateOrderAsync(CreateOrderRequest request, CancellationToken ct)
29{
30 // Validation
31 var validation = await _validator.ValidateAsync(request, ct);
32 if (!validation.IsValid)
33 return Result<Order>.Failure(
34 validation.Errors.First().ErrorMessage,
35 "VALIDATION_ERROR");
36
37 // Business rule check
38 var stock = await _stockService.CheckAsync(request.ProductId, request.Quantity, ct);
39 if (!stock.IsAvailable)
40 return Result<Order>.Failure(
41 $"Insufficient stock: {stock.Available} available, {request.Quantity} requested",
42 "INSUFFICIENT_STOCK");
43
44 // Create order
45 var order = await _repository.CreateAsync(request.ToEntity(), ct);
46
47 return Result<Order>.Success(order);
48}
49
50// Usage in controller/endpoint
51app.MapPost("/orders", async (
52 CreateOrderRequest request,
53 IOrderService orderService,
54 CancellationToken ct) =>
55{
56 var result = await orderService.CreateOrderAsync(request, ct);
57
58 return result.IsSuccess
59 ? Results.Created($"/orders/{result.Value!.Id}", result.Value)
60 : Results.BadRequest(new { error = result.Error, code = result.ErrorCode });
61});

Data Access Patterns

Entity Framework Core

 1// DbContext configuration
 2public class AppDbContext : DbContext
 3{
 4 public DbSet<Product> Products => Set<Product>();
 5 public DbSet<Order> Orders => Set<Order>();
 6
 7 protected override void OnModelCreating(ModelBuilder modelBuilder)
 8 {
 9 // Apply all configurations from assembly
10 modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);
11
12 // Global query filters
13 modelBuilder.Entity<Product>().HasQueryFilter(p => !p.IsDeleted);
14 }
15}
16
17// Entity configuration
18public class ProductConfiguration : IEntityTypeConfiguration<Product>
19{
20 public void Configure(EntityTypeBuilder<Product> builder)
21 {
22 builder.ToTable("Products");
23
24 builder.HasKey(p => p.Id);
25 builder.Property(p => p.Id).HasMaxLength(40);
26 builder.Property(p => p.Name).HasMaxLength(200).IsRequired();
27 builder.Property(p => p.Price).HasPrecision(18, 2);
28
29 builder.HasIndex(p => p.Sku).IsUnique();
30 builder.HasIndex(p => new { p.CategoryId, p.Name });
31
32 builder.HasMany(p => p.OrderItems)
33 .WithOne(oi => oi.Product)
34 .HasForeignKey(oi => oi.ProductId);
35 }
36}
37
38// Repository with EF Core
39public class ProductRepository : IProductRepository
40{
41 private readonly AppDbContext _context;
42
43 public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default)
44 {
45 return await _context.Products
46 .AsNoTracking()
47 .FirstOrDefaultAsync(p => p.Id == id, ct);
48 }
49
50 public async Task<IReadOnlyList<Product>> SearchAsync(
51 ProductSearchCriteria criteria,
52 CancellationToken ct = default)
53 {
54 var query = _context.Products.AsNoTracking();
55
56 if (!string.IsNullOrWhiteSpace(criteria.SearchTerm))
57 query = query.Where(p => EF.Functions.Like(p.Name, $"%{criteria.SearchTerm}%"));
58
59 if (criteria.CategoryId.HasValue)
60 query = query.Where(p => p.CategoryId == criteria.CategoryId);
61
62 if (criteria.MinPrice.HasValue)
63 query = query.Where(p => p.Price >= criteria.MinPrice);
64
65 if (criteria.MaxPrice.HasValue)
66 query = query.Where(p => p.Price <= criteria.MaxPrice);
67
68 return await query
69 .OrderBy(p => p.Name)
70 .Skip((criteria.Page - 1) * criteria.PageSize)
71 .Take(criteria.PageSize)
72 .ToListAsync(ct);
73 }
74}

Dapper for Performance

 1public class DapperProductRepository : IProductRepository
 2{
 3 private readonly IDbConnection _connection;
 4
 5 public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default)
 6 {
 7 const string sql = """
 8 SELECT Id, Name, Sku, Price, CategoryId, Stock, CreatedAt
 9 FROM Products
10 WHERE Id = @Id AND IsDeleted = 0
11 """;
12
13 return await _connection.QueryFirstOrDefaultAsync<Product>(
14 new CommandDefinition(sql, new { Id = id }, cancellationToken: ct));
15 }
16
17 public async Task<IReadOnlyList<Product>> SearchAsync(
18 ProductSearchCriteria criteria,
19 CancellationToken ct = default)
20 {
21 var sql = new StringBuilder("""
22 SELECT Id, Name, Sku, Price, CategoryId, Stock, CreatedAt
23 FROM Products
24 WHERE IsDeleted = 0
25 """);
26
27 var parameters = new DynamicParameters();
28
29 if (!string.IsNullOrWhiteSpace(criteria.SearchTerm))
30 {
31 sql.Append(" AND Name LIKE @SearchTerm");
32 parameters.Add("SearchTerm", $"%{criteria.SearchTerm}%");
33 }
34
35 if (criteria.CategoryId.HasValue)
36 {
37 sql.Append(" AND CategoryId = @CategoryId");
38 parameters.Add("CategoryId", criteria.CategoryId);
39 }
40
41 if (criteria.MinPrice.HasValue)
42 {
43 sql.Append(" AND Price >= @MinPrice");
44 parameters.Add("MinPrice", criteria.MinPrice);
45 }
46
47 if (criteria.MaxPrice.HasValue)
48 {
49 sql.Append(" AND Price <= @MaxPrice");
50 parameters.Add("MaxPrice", criteria.MaxPrice);
51 }
52
53 sql.Append(" ORDER BY Name OFFSET @Offset ROWS FETCH NEXT @PageSize ROWS ONLY");
54 parameters.Add("Offset", (criteria.Page - 1) * criteria.PageSize);
55 parameters.Add("PageSize", criteria.PageSize);
56
57 var results = await _connection.QueryAsync<Product>(
58 new CommandDefinition(sql.ToString(), parameters, cancellationToken: ct));
59
60 return results.ToList();
61 }
62
63 // Multi-mapping for related data
64 public async Task<Order?> GetOrderWithItemsAsync(int orderId, CancellationToken ct = default)
65 {
66 const string sql = """
67 SELECT o.*, oi.*, p.*
68 FROM Orders o
69 LEFT JOIN OrderItems oi ON o.Id = oi.OrderId
70 LEFT JOIN Products p ON oi.ProductId = p.Id
71 WHERE o.Id = @OrderId
72 """;
73
74 var orderDictionary = new Dictionary<int, Order>();
75
76 await _connection.QueryAsync<Order, OrderItem, Product, Order>(
77 new CommandDefinition(sql, new { OrderId = orderId }, cancellationToken: ct),
78 (order, item, product) =>
79 {
80 if (!orderDictionary.TryGetValue(order.Id, out var existingOrder))
81 {
82 existingOrder = order;
83 existingOrder.Items = new List<OrderItem>();
84 orderDictionary.Add(order.Id, existingOrder);
85 }
86
87 if (item != null)
88 {
89 item.Product = product;
90 existingOrder.Items.Add(item);
91 }
92
93 return existingOrder;
94 },
95 splitOn: "Id,Id");
96
97 return orderDictionary.Values.FirstOrDefault();
98 }
99}

Caching Patterns

Multi-Level Cache with Redis

 1public class CachedProductService : IProductService
 2{
 3 private readonly IProductRepository _repository;
 4 private readonly IMemoryCache _memoryCache;
 5 private readonly IDistributedCache _distributedCache;
 6 private readonly ILogger<CachedProductService> _logger;
 7
 8 private static readonly TimeSpan MemoryCacheDuration = TimeSpan.FromMinutes(1);
 9 private static readonly TimeSpan DistributedCacheDuration = TimeSpan.FromMinutes(15);
 10
 11 public async Task<Product?> GetByIdAsync(string id, CancellationToken ct = default)
 12 {
 13 var cacheKey = $"product:{id}";
 14
 15 // L1: Memory cache (in-process, fastest)
 16 if (_memoryCache.TryGetValue(cacheKey, out Product? cached))
 17 {
 18 _logger.LogDebug("L1 cache hit for {CacheKey}", cacheKey);
 19 return cached;
 20 }
 21
 22 // L2: Distributed cache (Redis)
 23 var distributed = await _distributedCache.GetStringAsync(cacheKey, ct);
 24 if (distributed != null)
 25 {
 26 _logger.LogDebug("L2 cache hit for {CacheKey}", cacheKey);
 27 var product = JsonSerializer.Deserialize<Product>(distributed);
 28
 29 // Populate L1
 30 _memoryCache.Set(cacheKey, product, MemoryCacheDuration);
 31 return product;
 32 }
 33
 34 // L3: Database
 35 _logger.LogDebug("Cache miss for {CacheKey}, fetching from database", cacheKey);
 36 var fromDb = await _repository.GetByIdAsync(id, ct);
 37
 38 if (fromDb != null)
 39 {
 40 var serialized = JsonSerializer.Serialize(fromDb);
 41
 42 // Populate both caches
 43 await _distributedCache.SetStringAsync(
 44 cacheKey,
 45 serialized,
 46 new DistributedCacheEntryOptions
 47 {
 48 AbsoluteExpirationRelativeToNow = DistributedCacheDuration
 49 },
 50 ct);
 51
 52 _memoryCache.Set(cacheKey, fromDb, MemoryCacheDuration);
 53 }
 54
 55 return fromDb;
 56 }
 57
 58 public async Task InvalidateAsync(string id, CancellationToken ct = default)
 59 {
 60 var cacheKey = $"product:{id}";
 61
 62 _memoryCache.Remove(cacheKey);
 63 await _distributedCache.RemoveAsync(cacheKey, ct);
 64
 65 _logger.LogInformation("Invalidated cache for {CacheKey}", cacheKey);
 66 }
 67}
 68
 69// Stale-while-revalidate pattern
 70public class StaleWhileRevalidateCache<T>
 71{
 72 private readonly IDistributedCache _cache;
 73 private readonly TimeSpan _freshDuration;
 74 private readonly TimeSpan _staleDuration;
 75
 76 public async Task<T?> GetOrCreateAsync(
 77 string key,
 78 Func<CancellationToken, Task<T>> factory,
 79 CancellationToken ct = default)
 80 {
 81 var cached = await _cache.GetStringAsync(key, ct);
 82
 83 if (cached != null)
 84 {
 85 var entry = JsonSerializer.Deserialize<CacheEntry<T>>(cached)!;
 86
 87 if (entry.IsStale && !entry.IsExpired)
 88 {
 89 // Return stale data immediately, refresh in background
 90 _ = Task.Run(async () =>
 91 {
 92 var fresh = await factory(CancellationToken.None);
 93 await SetAsync(key, fresh, CancellationToken.None);
 94 });
 95 }
 96
 97 if (!entry.IsExpired)
 98 return entry.Value;
 99 }
100
101 // Cache miss or expired
102 var value = await factory(ct);
103 await SetAsync(key, value, ct);
104 return value;
105 }
106
107 private record CacheEntry<TValue>(TValue Value, DateTime CreatedAt)
108 {
109 public bool IsStale => DateTime.UtcNow - CreatedAt > _freshDuration;
110 public bool IsExpired => DateTime.UtcNow - CreatedAt > _staleDuration;
111 }
112}

Testing Patterns

Unit Tests with xUnit and Moq

 1public class OrderServiceTests
 2{
 3 private readonly Mock<IOrderRepository> _mockRepository;
 4 private readonly Mock<IStockService> _mockStockService;
 5 private readonly Mock<IValidator<CreateOrderRequest>> _mockValidator;
 6 private readonly OrderService _sut; // System Under Test
 7
 8 public OrderServiceTests()
 9 {
 10 _mockRepository = new Mock<IOrderRepository>();
 11 _mockStockService = new Mock<IStockService>();
 12 _mockValidator = new Mock<IValidator<CreateOrderRequest>>();
 13
 14 // Default: validation passes
 15 _mockValidator
 16 .Setup(v => v.ValidateAsync(It.IsAny<CreateOrderRequest>(), It.IsAny<CancellationToken>()))
 17 .ReturnsAsync(new ValidationResult());
 18
 19 _sut = new OrderService(
 20 _mockRepository.Object,
 21 _mockStockService.Object,
 22 _mockValidator.Object);
 23 }
 24
 25 [Fact]
 26 public async Task CreateOrderAsync_WithValidRequest_ReturnsSuccess()
 27 {
 28 // Arrange
 29 var request = new CreateOrderRequest
 30 {
 31 ProductId = "PROD-001",
 32 Quantity = 5,
 33 CustomerOrderCode = "ORD-2024-001"
 34 };
 35
 36 _mockStockService
 37 .Setup(s => s.CheckAsync("PROD-001", 5, It.IsAny<CancellationToken>()))
 38 .ReturnsAsync(new StockResult { IsAvailable = true, Available = 10 });
 39
 40 _mockRepository
 41 .Setup(r => r.CreateAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()))
 42 .ReturnsAsync(new Order { Id = 1, CustomerOrderCode = "ORD-2024-001" });
 43
 44 // Act
 45 var result = await _sut.CreateOrderAsync(request);
 46
 47 // Assert
 48 Assert.True(result.IsSuccess);
 49 Assert.NotNull(result.Value);
 50 Assert.Equal(1, result.Value.Id);
 51
 52 _mockRepository.Verify(
 53 r => r.CreateAsync(It.Is<Order>(o => o.CustomerOrderCode == "ORD-2024-001"),
 54 It.IsAny<CancellationToken>()),
 55 Times.Once);
 56 }
 57
 58 [Fact]
 59 public async Task CreateOrderAsync_WithInsufficientStock_ReturnsFailure()
 60 {
 61 // Arrange
 62 var request = new CreateOrderRequest { ProductId = "PROD-001", Quantity = 100 };
 63
 64 _mockStockService
 65 .Setup(s => s.CheckAsync(It.IsAny<string>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
 66 .ReturnsAsync(new StockResult { IsAvailable = false, Available = 5 });
 67
 68 // Act
 69 var result = await _sut.CreateOrderAsync(request);
 70
 71 // Assert
 72 Assert.False(result.IsSuccess);
 73 Assert.Equal("INSUFFICIENT_STOCK", result.ErrorCode);
 74 Assert.Contains("5 available", result.Error);
 75
 76 _mockRepository.Verify(
 77 r => r.CreateAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()),
 78 Times.Never);
 79 }
 80
 81 [Theory]
 82 [InlineData(0)]
 83 [InlineData(-1)]
 84 [InlineData(-100)]
 85 public async Task CreateOrderAsync_WithInvalidQuantity_ReturnsValidationError(int quantity)
 86 {
 87 // Arrange
 88 var request = new CreateOrderRequest { ProductId = "PROD-001", Quantity = quantity };
 89
 90 _mockValidator
 91 .Setup(v => v.ValidateAsync(request, It.IsAny<CancellationToken>()))
 92 .ReturnsAsync(new ValidationResult(new[]
 93 {
 94 new ValidationFailure("Quantity", "Quantity must be greater than 0")
 95 }));
 96
 97 // Act
 98 var result = await _sut.CreateOrderAsync(request);
 99
100 // Assert
101 Assert.False(result.IsSuccess);
102 Assert.Equal("VALIDATION_ERROR", result.ErrorCode);
103 }
104}

Integration Tests with WebApplicationFactory

 1public class ProductsApiTests : IClassFixture<WebApplicationFactory<Program>>
 2{
 3 private readonly WebApplicationFactory<Program> _factory;
 4 private readonly HttpClient _client;
 5
 6 public ProductsApiTests(WebApplicationFactory<Program> factory)
 7 {
 8 _factory = factory.WithWebHostBuilder(builder =>
 9 {
10 builder.ConfigureServices(services =>
11 {
12 // Replace real database with in-memory
13 services.RemoveAll<DbContextOptions<AppDbContext>>();
14 services.AddDbContext<AppDbContext>(options =>
15 options.UseInMemoryDatabase("TestDb"));
16
17 // Replace Redis with memory cache
18 services.RemoveAll<IDistributedCache>();
19 services.AddDistributedMemoryCache();
20 });
21 });
22
23 _client = _factory.CreateClient();
24 }
25
26 [Fact]
27 public async Task GetProduct_WithValidId_ReturnsProduct()
28 {
29 // Arrange
30 using var scope = _factory.Services.CreateScope();
31 var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
32
33 context.Products.Add(new Product
34 {
35 Id = "TEST-001",
36 Name = "Test Product",
37 Price = 99.99m
38 });
39 await context.SaveChangesAsync();
40
41 // Act
42 var response = await _client.GetAsync("/api/products/TEST-001");
43
44 // Assert
45 response.EnsureSuccessStatusCode();
46 var product = await response.Content.ReadFromJsonAsync<Product>();
47 Assert.Equal("Test Product", product!.Name);
48 }
49
50 [Fact]
51 public async Task GetProduct_WithInvalidId_Returns404()
52 {
53 // Act
54 var response = await _client.GetAsync("/api/products/NONEXISTENT");
55
56 // Assert
57 Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
58 }
59}

Best Practices

DO

Use async/await all the way through the call stack
Inject dependencies through constructor injection
Use IOptions for typed configuration
Return Result types instead of throwing exceptions for business logic
Use CancellationToken in all async methods
Prefer Dapper for read-heavy, performance-critical queries
Use EF Core for complex domain models with change tracking
Cache aggressively with proper invalidation strategies
Write unit tests for business logic, integration tests for APIs
Use record types for DTOs and immutable data

DON’T

Don’t block on async with .Result or .Wait()
Don’t use async void except for event handlers
Don’t catch generic Exception without re-throwing or logging
Don’t hardcode configuration values
Don’t expose EF entities directly in APIs (use DTOs)
Don’t forget AsNoTracking() for read-only queries
Don’t ignore CancellationToken parameters
Don’t create new HttpClient() manually (use IHttpClientFactory)
Don’t mix sync and async code unnecessarily
Don’t skip validation at API boundaries

Common Pitfalls

N+1 Queries: Use .Include() or explicit joins
Memory Leaks: Dispose IDisposable resources, use using
Deadlocks: Don’t mix sync and async, use ConfigureAwait(false) in libraries
Over-fetching: Select only needed columns, use projections
Missing Indexes: Check query plans, add indexes for common filters
Timeout Issues: Configure appropriate timeouts for HTTP clients
Cache Stampede: Use distributed locks for cache population

Resources

assets/service-template.cs: Complete service implementation template
assets/repository-template.cs: Repository pattern implementation
references/ef-core-best-practices.md: EF Core optimization guide
references/dapper-patterns.md: Advanced Dapper usage patterns

E2E Testing Patterns

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

E2E Testing Patterns

Build reliable, fast, and maintainable end-to-end test suites that provide confidence to ship code quickly and catch regressions before users do.

When to Use This Skill

Implementing end-to-end test automation
Debugging flaky or unreliable tests
Testing critical user workflows
Setting up CI/CD test pipelines
Testing across multiple browsers
Validating accessibility requirements
Testing responsive designs
Establishing E2E testing standards

Core Concepts

1. E2E Testing Fundamentals

What to Test with E2E:

Email Composer

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

Email Composer

Quick start

Provide context and purpose, and I’ll draft an appropriate email.

What I need:

Purpose of email (request, follow-up, announcement, etc.)
Recipient relationship (colleague, customer, manager, vendor)
Key points to include
Desired tone (formal, casual, urgent, friendly)

Email structure

Standard professional email format:

Subject: [Clear, specific subject line]

[Greeting],

[Opening - context/purpose]

[Body - main points]

[Closing - call to action]

[Sign-off]
[Your name]

Common email types

Request for information

Subject: Question about Q4 project timeline

Hi [Name],

I hope this email finds you well. I'm reaching out regarding the Q4 product launch timeline.

Could you provide an update on:
- Current progress on feature development
- Expected completion date for testing phase
- Any blockers or dependencies we should be aware of

This will help us coordinate with the marketing team for the launch materials.

Thanks in advance for your help!

Best regards,
[Your name]

Follow-up email

Subject: Following up: Proposal for new payment system

Hi [Name],

I wanted to follow up on the payment system proposal I sent last week. I understand you're busy, so I wanted to make sure it didn't get lost in your inbox.

To recap, the proposed system would:
- Reduce transaction fees by 30%
- Integrate with existing accounting software
- Improve customer checkout experience

I'd be happy to schedule a brief call to discuss any questions you might have.

Looking forward to hearing from you.

Best,
[Your name]

Technical update

Subject: API Maintenance Window - [Date]

Team,

This is a reminder that we'll be performing scheduled maintenance on our API infrastructure on [Date] from [Time] to [Time] [Timezone].

During this window:
- API endpoints will be unavailable
- Database will be upgraded to v14
- SSL certificates will be renewed

Expected downtime: 2 hours

What you need to do:
- Notify your users of the planned downtime
- Ensure retry logic is in place for API calls
- Monitor your application after maintenance completes

If you have any concerns or conflicts with this schedule, please let me know by [Date].

Technical details available in our status page: [link]

Thanks,
[Your name]

Customer support

Subject: Re: Issue with order #12345

Hi [Customer name],

Thank you for reaching out about your order. I'm sorry to hear you're experiencing this issue.

I've looked into your order (#12345) and found the following:

[Explanation of the issue]

To resolve this, I've:
- [Action taken 1]
- [Action taken 2]

You should see [expected outcome] within [timeframe].

If you continue to experience any problems, please don't hesitate to reply to this email or call us at [phone number].

We appreciate your patience and understanding.

Best regards,
[Your name]
Customer Support Team

Meeting request

Subject: Meeting request: Discuss database migration strategy

Hi [Name],

I'd like to schedule a meeting to discuss our approach for the upcoming database migration.

Agenda items:
- Review migration timeline and milestones
- Discuss rollback strategy
- Identify potential risks and mitigation plans
- Assign team responsibilities

Estimated duration: 45 minutes

I'm available:
- Monday 2-4 PM
- Wednesday 10 AM - 12 PM
- Friday 1-3 PM

Please let me know what works best for you, or feel free to suggest alternative times.

Best,
[Your name]

Tone guidelines

Formal tone

Use complete sentences
Avoid contractions
Professional language
Proper titles (Dr., Mr., Ms.)

Casual tone

Contractions acceptable
Conversational language
Still professional
First names

Urgent tone

Clear subject line with [URGENT] or [ACTION REQUIRED]
Bold key points
Explicit deadline
Direct call to action

Subject line best practices

Good subject lines:

Error Handling Patterns

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

Error Handling Patterns

Build resilient applications with robust error handling strategies that gracefully handle failures and provide excellent debugging experiences.

When to Use This Skill

Implementing error handling in new features
Designing error-resilient APIs
Debugging production issues
Improving application reliability
Creating better error messages for users and developers
Implementing retry and circuit breaker patterns
Handling async/concurrent errors
Building fault-tolerant distributed systems

Core Concepts

1. Error Handling Philosophies

Exceptions vs Result Types:

Error Resolver

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

Error Resolver

A first-principle approach to diagnosing and resolving errors across all languages and frameworks.

Core Philosophy

The 5-step Error Resolution Process:

1. CLASSIFY -> 2. PARSE -> 3. MATCH -> 4. ANALYZE -> 5. RESOLVE
 | | | | |
 What type? Extract key Known Root cause Fix +
 information pattern? analysis Prevent

Quick Start

When you encounter an error:

Paste the full error (including stack trace if available)
Provide context (what were you trying to do?)
Share relevant code (the file/function involved)

Error Classification Framework

Primary Categories

Category	Indicators	Common Causes
Syntax	Parse error, Unexpected token	Typos, missing brackets, invalid syntax
Type	TypeError, type mismatch	Wrong data type, null/undefined access
Reference	ReferenceError, NameError	Undefined variable, scope issues
Runtime	RuntimeError, Exception	Logic errors, invalid operations
Network	ECONNREFUSED, timeout, 4xx/5xx	Connection issues, wrong URL, server down
Permission	EACCES, PermissionError	File/directory access, sudo needed
Dependency	ModuleNotFound, Cannot find module	Missing package, version mismatch
Configuration	Config error, env missing	Wrong settings, missing env vars
Database	Connection refused, query error	DB down, wrong credentials, bad query
Memory	OOM, heap out of memory	Memory leak, large data processing

Secondary Attributes

Severity: Fatal / Error / Warning / Info
Scope: Build-time / Runtime / Test-time
Origin: User code / Framework / Third-party / System

Analysis Workflow

Step 1: Classify

Identify the error category by examining:

Error Tracking

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

your project Sentry Integration Skill

Purpose

This skill enforces comprehensive Sentry error tracking and performance monitoring across all your project services following Sentry v8 patterns.

When to Use This Skill

Adding error handling to any code
Creating new controllers or routes
Instrumenting cron jobs
Tracking database performance
Adding performance spans
Handling workflow errors

🚨 CRITICAL RULE

ALL ERRORS MUST BE CAPTURED TO SENTRY - No exceptions. Never use console.error alone.

Evals Context

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

Evals Codebase Context

When to Use This Skill

Use this skill when the task involves:

Modifying or debugging the evals execution infrastructure
Adding new eval exercises or languages
Working with the evals web interface (apps/web-evals)
Modifying the public evals display page on roocode.com
Understanding where evals code lives in this monorepo

When NOT to Use This Skill

Do NOT use this skill when:

Working on unrelated parts of the codebase (extension, webview-ui, etc.)
The task is purely about the VS Code extension’s core functionality
Working on the main website pages that don’t involve evals

Key Disambiguation: Two “Evals” Locations

This monorepo has two distinct evals-related locations that can cause confusion:

Event Store Design

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

Event Store Design

Comprehensive guide to designing event stores for event-sourced applications.

When to Use This Skill

Designing event sourcing infrastructure
Choosing between event store technologies
Implementing custom event stores
Optimizing event storage and retrieval
Setting up event store schemas
Planning for event store scaling

Core Concepts

1. Event Store Architecture

┌─────────────────────────────────────────────────────┐
│ Event Store │
├─────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Stream 1 │ │ Stream 2 │ │ Stream 3 │ │
│ │ (Aggregate) │ │ (Aggregate) │ │ (Aggregate) │ │
│ ├─────────────┤ ├─────────────┤ ├─────────────┤ │
│ │ Event 1 │ │ Event 1 │ │ Event 1 │ │
│ │ Event 2 │ │ Event 2 │ │ Event 2 │ │
│ │ Event 3 │ │ ... │ │ Event 3 │ │
│ │ ... │ │ │ │ Event 4 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────┤
│ Global Position: 1 → 2 → 3 → 4 → 5 → 6 → ... │
└─────────────────────────────────────────────────────┘

2. Event Store Requirements

Requirement	Description
Append-only	Events are immutable, only appends
Ordered	Per-stream and global ordering
Versioned	Optimistic concurrency control
Subscriptions	Real-time event notifications
Idempotent	Handle duplicate writes safely

Technology Comparison

Technology	Best For	Limitations
EventStoreDB	Pure event sourcing	Single-purpose
PostgreSQL	Existing Postgres stack	Manual implementation
Kafka	High-throughput streaming	Not ideal for per-stream queries
DynamoDB	Serverless, AWS-native	Query limitations
Marten	.NET ecosystems	.NET specific

Templates

Template 1: PostgreSQL Event Store Schema

 1-- Events table
 2CREATE TABLE events (
 3 id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
 4 stream_id VARCHAR(255) NOT NULL,
 5 stream_type VARCHAR(255) NOT NULL,
 6 event_type VARCHAR(255) NOT NULL,
 7 event_data JSONB NOT NULL,
 8 metadata JSONB DEFAULT '{}',
 9 version BIGINT NOT NULL,
10 global_position BIGSERIAL,
11 created_at TIMESTAMPTZ DEFAULT NOW(),
12
13 CONSTRAINT unique_stream_version UNIQUE (stream_id, version)
14);
15
16-- Index for stream queries
17CREATE INDEX idx_events_stream_id ON events(stream_id, version);
18
19-- Index for global subscription
20CREATE INDEX idx_events_global_position ON events(global_position);
21
22-- Index for event type queries
23CREATE INDEX idx_events_event_type ON events(event_type);
24
25-- Index for time-based queries
26CREATE INDEX idx_events_created_at ON events(created_at);
27
28-- Snapshots table
29CREATE TABLE snapshots (
30 stream_id VARCHAR(255) PRIMARY KEY,
31 stream_type VARCHAR(255) NOT NULL,
32 snapshot_data JSONB NOT NULL,
33 version BIGINT NOT NULL,
34 created_at TIMESTAMPTZ DEFAULT NOW()
35);
36
37-- Subscriptions checkpoint table
38CREATE TABLE subscription_checkpoints (
39 subscription_id VARCHAR(255) PRIMARY KEY,
40 last_position BIGINT NOT NULL DEFAULT 0,
41 updated_at TIMESTAMPTZ DEFAULT NOW()
42);

Template 2: Python Event Store Implementation

 1from dataclasses import dataclass, field
 2from datetime import datetime
 3from typing import Any, Optional, List
 4from uuid import UUID, uuid4
 5import json
 6import asyncpg
 7
 8@dataclass
 9class Event:
 10 stream_id: str
 11 event_type: str
 12 data: dict
 13 metadata: dict = field(default_factory=dict)
 14 event_id: UUID = field(default_factory=uuid4)
 15 version: Optional[int] = None
 16 global_position: Optional[int] = None
 17 created_at: datetime = field(default_factory=datetime.utcnow)
 18
 19
 20class EventStore:
 21 def __init__(self, pool: asyncpg.Pool):
 22 self.pool = pool
 23
 24 async def append_events(
 25 self,
 26 stream_id: str,
 27 stream_type: str,
 28 events: List[Event],
 29 expected_version: Optional[int] = None
 30 ) -> List[Event]:
 31 """Append events to a stream with optimistic concurrency."""
 32 async with self.pool.acquire() as conn:
 33 async with conn.transaction():
 34 # Check expected version
 35 if expected_version is not None:
 36 current = await conn.fetchval(
 37 "SELECT MAX(version) FROM events WHERE stream_id = $1",
 38 stream_id
 39 )
 40 current = current or 0
 41 if current != expected_version:
 42 raise ConcurrencyError(
 43 f"Expected version {expected_version}, got {current}"
 44 )
 45
 46 # Get starting version
 47 start_version = await conn.fetchval(
 48 "SELECT COALESCE(MAX(version), 0) + 1 FROM events WHERE stream_id = $1",
 49 stream_id
 50 )
 51
 52 # Insert events
 53 saved_events = []
 54 for i, event in enumerate(events):
 55 event.version = start_version + i
 56 row = await conn.fetchrow(
 57 """
 58 INSERT INTO events (id, stream_id, stream_type, event_type,
 59 event_data, metadata, version, created_at)
 60 VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
 61 RETURNING global_position
 62 """,
 63 event.event_id,
 64 stream_id,
 65 stream_type,
 66 event.event_type,
 67 json.dumps(event.data),
 68 json.dumps(event.metadata),
 69 event.version,
 70 event.created_at
 71 )
 72 event.global_position = row['global_position']
 73 saved_events.append(event)
 74
 75 return saved_events
 76
 77 async def read_stream(
 78 self,
 79 stream_id: str,
 80 from_version: int = 0,
 81 limit: int = 1000
 82 ) -> List[Event]:
 83 """Read events from a stream."""
 84 async with self.pool.acquire() as conn:
 85 rows = await conn.fetch(
 86 """
 87 SELECT id, stream_id, event_type, event_data, metadata,
 88 version, global_position, created_at
 89 FROM events
 90 WHERE stream_id = $1 AND version >= $2
 91 ORDER BY version
 92 LIMIT $3
 93 """,
 94 stream_id, from_version, limit
 95 )
 96 return [self._row_to_event(row) for row in rows]
 97
 98 async def read_all(
 99 self,
100 from_position: int = 0,
101 limit: int = 1000
102 ) -> List[Event]:
103 """Read all events globally."""
104 async with self.pool.acquire() as conn:
105 rows = await conn.fetch(
106 """
107 SELECT id, stream_id, event_type, event_data, metadata,
108 version, global_position, created_at
109 FROM events
110 WHERE global_position > $1
111 ORDER BY global_position
112 LIMIT $2
113 """,
114 from_position, limit
115 )
116 return [self._row_to_event(row) for row in rows]
117
118 async def subscribe(
119 self,
120 subscription_id: str,
121 handler,
122 from_position: int = 0,
123 batch_size: int = 100
124 ):
125 """Subscribe to all events from a position."""
126 # Get checkpoint
127 async with self.pool.acquire() as conn:
128 checkpoint = await conn.fetchval(
129 """
130 SELECT last_position FROM subscription_checkpoints
131 WHERE subscription_id = $1
132 """,
133 subscription_id
134 )
135 position = checkpoint or from_position
136
137 while True:
138 events = await self.read_all(position, batch_size)
139 if not events:
140 await asyncio.sleep(1) # Poll interval
141 continue
142
143 for event in events:
144 await handler(event)
145 position = event.global_position
146
147 # Save checkpoint
148 async with self.pool.acquire() as conn:
149 await conn.execute(
150 """
151 INSERT INTO subscription_checkpoints (subscription_id, last_position)
152 VALUES ($1, $2)
153 ON CONFLICT (subscription_id)
154 DO UPDATE SET last_position = $2, updated_at = NOW()
155 """,
156 subscription_id, position
157 )
158
159 def _row_to_event(self, row) -> Event:
160 return Event(
161 event_id=row['id'],
162 stream_id=row['stream_id'],
163 event_type=row['event_type'],
164 data=json.loads(row['event_data']),
165 metadata=json.loads(row['metadata']),
166 version=row['version'],
167 global_position=row['global_position'],
168 created_at=row['created_at']
169 )
170
171
172class ConcurrencyError(Exception):
173 """Raised when optimistic concurrency check fails."""
174 pass

Template 3: EventStoreDB Usage

 1from esdbclient import EventStoreDBClient, NewEvent, StreamState
 2import json
 3
 4# Connect
 5client = EventStoreDBClient(uri="esdb://localhost:2113?tls=false")
 6
 7# Append events
 8def append_events(stream_name: str, events: list, expected_revision=None):
 9 new_events = [
10 NewEvent(
11 type=event['type'],
12 data=json.dumps(event['data']).encode(),
13 metadata=json.dumps(event.get('metadata', {})).encode()
14 )
15 for event in events
16 ]
17
18 if expected_revision is None:
19 state = StreamState.ANY
20 elif expected_revision == -1:
21 state = StreamState.NO_STREAM
22 else:
23 state = expected_revision
24
25 return client.append_to_stream(
26 stream_name=stream_name,
27 events=new_events,
28 current_version=state
29 )
30
31# Read stream
32def read_stream(stream_name: str, from_revision: int = 0):
33 events = client.get_stream(
34 stream_name=stream_name,
35 stream_position=from_revision
36 )
37 return [
38 {
39 'type': event.type,
40 'data': json.loads(event.data),
41 'metadata': json.loads(event.metadata) if event.metadata else {},
42 'stream_position': event.stream_position,
43 'commit_position': event.commit_position
44 }
45 for event in events
46 ]
47
48# Subscribe to all
49async def subscribe_to_all(handler, from_position: int = 0):
50 subscription = client.subscribe_to_all(commit_position=from_position)
51 async for event in subscription:
52 await handler({
53 'type': event.type,
54 'data': json.loads(event.data),
55 'stream_id': event.stream_name,
56 'position': event.commit_position
57 })
58
59# Category projection ($ce-Category)
60def read_category(category: str):
61 """Read all events for a category using system projection."""
62 return read_stream(f"$ce-{category}")

Template 4: DynamoDB Event Store

 1import boto3
 2from boto3.dynamodb.conditions import Key
 3from datetime import datetime
 4import json
 5import uuid
 6
 7class DynamoEventStore:
 8 def __init__(self, table_name: str):
 9 self.dynamodb = boto3.resource('dynamodb')
10 self.table = self.dynamodb.Table(table_name)
11
12 def append_events(self, stream_id: str, events: list, expected_version: int = None):
13 """Append events with conditional write for concurrency."""
14 with self.table.batch_writer() as batch:
15 for i, event in enumerate(events):
16 version = (expected_version or 0) + i + 1
17 item = {
18 'PK': f"STREAM#{stream_id}",
19 'SK': f"VERSION#{version:020d}",
20 'GSI1PK': 'EVENTS',
21 'GSI1SK': datetime.utcnow().isoformat(),
22 'event_id': str(uuid.uuid4()),
23 'stream_id': stream_id,
24 'event_type': event['type'],
25 'event_data': json.dumps(event['data']),
26 'version': version,
27 'created_at': datetime.utcnow().isoformat()
28 }
29 batch.put_item(Item=item)
30 return events
31
32 def read_stream(self, stream_id: str, from_version: int = 0):
33 """Read events from a stream."""
34 response = self.table.query(
35 KeyConditionExpression=Key('PK').eq(f"STREAM#{stream_id}") &
36 Key('SK').gte(f"VERSION#{from_version:020d}")
37 )
38 return [
39 {
40 'event_type': item['event_type'],
41 'data': json.loads(item['event_data']),
42 'version': item['version']
43 }
44 for item in response['Items']
45 ]
46
47# Table definition (CloudFormation/Terraform)
48"""
49DynamoDB Table:
50 - PK (Partition Key): String
51 - SK (Sort Key): String
52 - GSI1PK, GSI1SK for global ordering
53
54Capacity: On-demand or provisioned based on throughput needs
55"""

Best Practices

Do’s

Use stream IDs that include aggregate type - Order-{uuid}
Include correlation/causation IDs - For tracing
Version events from day one - Plan for schema evolution
Implement idempotency - Use event IDs for deduplication
Index appropriately - For your query patterns

Don’ts

Don’t update or delete events - They’re immutable facts
Don’t store large payloads - Keep events small
Don’t skip optimistic concurrency - Prevents data corruption
Don’t ignore backpressure - Handle slow consumers

Resources

Examples Auto Run

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

examples-auto-run

What it does

Runs uv run examples/run_examples.py with:
- EXAMPLES_INTERACTIVE_MODE=auto (auto-input/auto-approve).
- Per-example logs under .tmp/examples-start-logs/.
- Main summary log path passed via --main-log (also under .tmp/examples-start-logs/).
- Generates a rerun list of failures at .tmp/examples-rerun.txt when --write-rerun is set.
Provides start/stop/status/logs/tail/collect/rerun helpers via run.sh.
Background option keeps the process running with a pidfile; stop cleans it up.

Usage

 1# Start (auto mode; interactive included by default)
 2.codex/skills/examples-auto-run/scripts/run.sh start [extra args to run_examples.py]
 3# Examples:
 4.codex/skills/examples-auto-run/scripts/run.sh start --filter basic
 5.codex/skills/examples-auto-run/scripts/run.sh start --include-server --include-audio
 6
 7# Check status
 8.codex/skills/examples-auto-run/scripts/run.sh status
 9
10# Stop running job
11.codex/skills/examples-auto-run/scripts/run.sh stop
12
13# List logs
14.codex/skills/examples-auto-run/scripts/run.sh logs
15
16# Tail latest log (or specify one)
17.codex/skills/examples-auto-run/scripts/run.sh tail
18.codex/skills/examples-auto-run/scripts/run.sh tail main_20260113-123000.log
19
20# Collect rerun list from a main log (defaults to latest main_*.log)
21.codex/skills/examples-auto-run/scripts/run.sh collect
22
23# Rerun only failed entries from rerun file (auto mode)
24.codex/skills/examples-auto-run/scripts/run.sh rerun

Defaults (overridable via env)

EXAMPLES_INTERACTIVE_MODE=auto
EXAMPLES_INCLUDE_INTERACTIVE=1
EXAMPLES_INCLUDE_SERVER=0
EXAMPLES_INCLUDE_AUDIO=0
EXAMPLES_INCLUDE_EXTERNAL=0
Auto-approvals in auto mode: APPLY_PATCH_AUTO_APPROVE=1, SHELL_AUTO_APPROVE=1, AUTO_APPROVE_MCP=1

Log locations

Main logs: .tmp/examples-start-logs/main_*.log
Per-example logs (from run_examples.py): .tmp/examples-start-logs/<module_path>.log
Rerun list: .tmp/examples-rerun.txt
Stdout logs: .tmp/examples-start-logs/stdout_*.log

Notes

The runner delegates to uv run examples/run_examples.py, which already writes per-example logs and supports --collect, --rerun-file, and --print-auto-skip.
start uses --write-rerun so failures are captured automatically.
If .tmp/examples-rerun.txt exists and is non-empty, invoking the skill with no args runs rerun by default.

Behavioral validation (Codex/LLM responsibility)

The runner does not perform any automated behavioral validation. After every foreground start or rerun, Codex must manually validate all exit-0 entries:

Excel Analysis

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

Excel Analysis

Quick start

Read Excel files with pandas:

 1import pandas as pd
 2
 3# Read Excel file
 4df = pd.read_excel("data.xlsx", sheet_name="Sheet1")
 5
 6# Display first few rows
 7print(df.head())
 8
 9# Basic statistics
10print(df.describe())

Reading multiple sheets

Process all sheets in a workbook:

Executing Marketing Campaigns

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

Executing Marketing Campaigns

This Skill helps marketing teams plan campaigns, develop messaging, manage execution across channels, and measure results. Use this when developing marketing strategies, creating campaign content, planning social media, drafting emails, or analyzing campaign performance.

Campaign Planning: See campaigns.md for structured campaign development
Content Creation: See content.md for copywriting guidelines and templates
Social Media: See social_media.md for platform-specific strategies
Email Marketing: See email.md for email templates and best practices
Analytics & Measurement: See analytics.md for KPIs and reporting
Brand Guidelines: See brand.md for company voice and visual standards
Templates & Tools: See templates.md for ready-to-use templates

Core Principles

Key Marketing Terminology (Consistent Throughout)

Campaign: A coordinated set of marketing activities with unified messaging around a specific goal
Channels: Distribution platforms (email, social media, paid ads, blog, etc.)
Target Audience: Specific demographic/psychographic segments the campaign addresses
Engagement Rate: Percentage of audience who interact with content
Conversion: A desired action (signup, purchase, demo request, etc.)
CTR (Click-Through Rate): Percentage of impressions that result in clicks
CAC (Customer Acquisition Cost): Total marketing spend divided by new customers acquired

Workflow: Campaign Development & Execution

When developing a marketing campaign, follow this structured approach:

Fastapi Templates

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

FastAPI Project Templates

Production-ready FastAPI project structures with async patterns, dependency injection, middleware, and best practices for building high-performance APIs.

When to Use This Skill

Starting new FastAPI projects from scratch
Implementing async REST APIs with Python
Building high-performance web services and microservices
Creating async applications with PostgreSQL, MongoDB
Setting up API projects with proper structure and testing

Core Concepts

1. Project Structure

Recommended Layout:

app/
├── api/ # API routes
│ ├── v1/
│ │ ├── endpoints/
│ │ │ ├── users.py
│ │ │ ├── auth.py
│ │ │ └── items.py
│ │ └── router.py
│ └── dependencies.py # Shared dependencies
├── core/ # Core configuration
│ ├── config.py
│ ├── security.py
│ └── database.py
├── models/ # Database models
│ ├── user.py
│ └── item.py
├── schemas/ # Pydantic schemas
│ ├── user.py
│ └── item.py
├── services/ # Business logic
│ ├── user_service.py
│ └── auth_service.py
├── repositories/ # Data access
│ ├── user_repository.py
│ └── item_repository.py
└── main.py # Application entry

2. Dependency Injection

FastAPI’s built-in DI system using Depends:

Feature Design Assistant

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

Feature Design Assistant

Help turn ideas into fully formed designs and specs through structured information gathering and collaborative validation.

Announce at start: “I’m using the feature-design-assistant skill to design this feature.”

Phase 1: Context Discovery

First, explore the codebase to understand:

Project structure and tech stack
Existing patterns and conventions
Related features or modules
Recent changes in relevant areas

Phase 2: Structured Information Gathering

Use AskUserQuestion to batch collect information efficiently. Each call can ask up to 4 questions.

Fetch Diff

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

Fetch PR Diff

Fetches a pull request diff, filters out auto-generated files, and adds line numbers for easier review comment placement.

Usage

1uv run skills fetch-diff <pr_url>

Example:

1uv run skills fetch-diff https://github.com/mlflow/mlflow/pull/123

Token is auto-detected from GH_TOKEN env var or gh auth token.

Output Example

diff --git a/path/to/file.py b/path/to/file.py
index abc123..def456 100644
--- a/path/to/file.py
+++ b/path/to/file.py
@@ -10,7 +10,7 @@
10 10 | import os
11 11 | import sys
12 12 | from typing import Optional
13 | -from old_module import OldClass
 14 | +from new_module import NewClass
14 15 |
15 16 | def process_data(input_file: str) -> dict:

File Organizer

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

File Organizer

This skill acts as your personal organization assistant, helping you maintain a clean, logical file structure across your computer without the mental overhead of constant manual organization.

When to Use This Skill

Your Downloads folder is a chaotic mess
You can’t find files because they’re scattered everywhere
You have duplicate files taking up space
Your folder structure doesn’t make sense anymore
You want to establish better organization habits
You’re starting a new project and need a good structure
You’re cleaning up before archiving old projects

What This Skill Does

Analyzes Current Structure: Reviews your folders and files to understand what you have
Finds Duplicates: Identifies duplicate files across your system
Suggests Organization: Proposes logical folder structures based on your content
Automates Cleanup: Moves, renames, and organizes files with your approval
Maintains Context: Makes smart decisions based on file types, dates, and content
Reduces Clutter: Identifies old files you probably don’t need anymore

How to Use

From Your Home Directory

cd ~

Then run Claude Code and ask for help:

Find Bugs

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

Find Bugs

Review changes on this branch for bugs, security vulnerabilities, and code quality issues.

Phase 1: Complete Input Gathering

Get the FULL diff: git diff master...HEAD
If output is truncated, read each changed file individually until you have seen every changed line
List all files modified in this branch before proceeding

Phase 2: Attack Surface Mapping

For each changed file, identify and list:

All user inputs (request params, headers, body, URL components)
All database queries
All authentication/authorization checks
All session/state operations
All external calls
All cryptographic operations

Phase 3: Security Checklist (check EVERY item for EVERY file)

Injection: SQL, command, template, header injection
XSS: All outputs in templates properly escaped?
Authentication: Auth checks on all protected operations?
Authorization/IDOR: Access control verified, not just auth?
CSRF: State-changing operations protected?
Race conditions: TOCTOU in any read-then-write patterns?
Session: Fixation, expiration, secure flags?
Cryptography: Secure random, proper algorithms, no secrets in logs?
Information disclosure: Error messages, logs, timing attacks?
DoS: Unbounded operations, missing rate limits, resource exhaustion?
Business logic: Edge cases, state machine violations, numeric overflow?

Phase 4: Verification

For each potential issue:

Flow Nexus Platform

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

Flow Nexus Platform Management

Comprehensive platform management for Flow Nexus - covering authentication, sandbox execution, app deployment, credit management, and coding challenges.

Authentication & User Management

Register New Account

1mcp__flow-nexus__user_register({
2 email: "user@example.com",
3 password: "secure_password",
4 full_name: "Your Name",
5 username: "unique_username" // optional
6})

Login

Flow Nexus Swarm

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

Flow Nexus Swarm & Workflow Orchestration

Deploy and manage cloud-based AI agent swarms with event-driven workflow automation, message queue processing, and intelligent agent coordination.

📋 Table of Contents

Overview

Flow Nexus provides cloud-based orchestration for AI agent swarms with:

Multi-topology Support: Hierarchical, mesh, ring, and star architectures
Event-driven Workflows: Message queue processing with async execution
Template Library: Pre-built swarm configurations for common use cases
Intelligent Agent Assignment: Vector similarity matching for optimal agent selection
Real-time Monitoring: Comprehensive metrics and audit trails
Scalable Infrastructure: Cloud-based execution with auto-scaling

Swarm Management

Initialize Swarm

Create a new swarm with specified topology and configuration:

Frontend Design

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

This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic “AI slop” aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.

The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.

Design Thinking

Before coding, understand the context and commit to a BOLD aesthetic direction:

Purpose: What problem does this interface solve? Who uses it?
Tone: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
Constraints: Technical requirements (framework, performance, accessibility).
Differentiation: What makes this UNFORGETTABLE? What’s the one thing someone will remember?

CRITICAL: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.

Frontend Dev Guidelines

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

Frontend Development Guidelines

Purpose

Comprehensive guide for modern React development, emphasizing Suspense-based data fetching, lazy loading, proper file organization, and performance optimization.

When to Use This Skill

Creating new components or pages
Building new features
Fetching data with TanStack Query
Setting up routing with TanStack Router
Styling components with MUI v7
Performance optimization
Organizing frontend code
TypeScript best practices

Quick Start

New Component Checklist

Creating a component? Follow this checklist:

Generate Component Story

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

Instructions

When creating component stories:

Follow existing patterns: Base stories on the styles found in crates/story/src/stories (examples: tabs_story.rs, group_box_story.rs, etc.)
Use sections: Organize the story with section! calls for each major part
Comprehensive coverage: Include all options, variants, and usage examples of the component

Examples

A typical story structure includes:

Basic usage examples
Different variants and states
Interactive examples
Edge cases and error states

Generate Release Notes

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

Generate Release Notes for Bit

This skill helps generate release notes for Bit following the established patterns and guidelines.

Important: Intermediate Files

All intermediate steps must be saved to releases-docs/temp-files/ for review. This folder is gitignored.

Required intermediate files:

raw-commits.md - Raw commit data from GitHub API
filtered-commits.md - Two sections: filtered out commits and kept commits

Workflow

Follow these steps to generate release notes:

Step 1: Setup Temp Directory

First, ensure the temp directory exists:

Gh Fix Ci

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

Gh Pr Checks Plan Fix

Overview

Use gh to locate failing PR checks, fetch GitHub Actions logs for actionable failures, summarize the failure snippet, then propose a fix plan and implement after explicit approval.

Depends on the plan skill for drafting and approving the fix plan.

Prereq: ensure gh is authenticated (for example, run gh auth login once), then run gh auth status with escalated permissions (include workflow/repo scopes) so gh commands succeed. If sandboxing blocks gh auth status, rerun it with sandbox_permissions=require_escalated.

Git Commit Helper

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

Git Commit Helper

Quick start

Analyze staged changes and generate commit message:

1# View staged changes
2git diff --staged
3
4# Generate commit message based on changes
5# (Claude will analyze the diff and suggest a message)

Commit message format

Follow conventional commits format:

<type>(<scope>): <description>

[optional body]

[optional footer]

Types

feat: New feature
fix: Bug fix
docs: Documentation changes
style: Code style changes (formatting, missing semicolons)
refactor: Code refactoring
test: Adding or updating tests
chore: Maintenance tasks

Examples

Feature commit:

Github Actions Templates

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

GitHub Actions Templates

Production-ready GitHub Actions workflow patterns for testing, building, and deploying applications.

Purpose

Create efficient, secure GitHub Actions workflows for continuous integration and deployment across various tech stacks.

When to Use

Automate testing and deployment
Build Docker images and push to registries
Deploy to Kubernetes clusters
Run security scans
Implement matrix builds for multiple environments

Common Workflow Patterns

Pattern 1: Test Workflow

 1name: Test
 2
 3on:
 4 push:
 5 branches: [main, develop]
 6 pull_request:
 7 branches: [main]
 8
 9jobs:
10 test:
11 runs-on: ubuntu-latest
12
13 strategy:
14 matrix:
15 node-version: [18.x, 20.x]
16
17 steps:
18 - uses: actions/checkout@v4
19
20 - name: Use Node.js ${{ matrix.node-version }}
21 uses: actions/setup-node@v4
22 with:
23 node-version: ${{ matrix.node-version }}
24 cache: "npm"
25
26 - name: Install dependencies
27 run: npm ci
28
29 - name: Run linter
30 run: npm run lint
31
32 - name: Run tests
33 run: npm test
34
35 - name: Upload coverage
36 uses: codecov/codecov-action@v3
37 with:
38 files: ./coverage/lcov.info

Reference: See assets/test-workflow.yml

Github Issues

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

GitHub Issues

Manage GitHub issues using the @modelcontextprotocol/server-github MCP server.

Available MCP Tools

Tool	Purpose
`mcp__github__create_issue`	Create new issues
`mcp__github__update_issue`	Update existing issues
`mcp__github__get_issue`	Fetch issue details
`mcp__github__search_issues`	Search issues
`mcp__github__add_issue_comment`	Add comments
`mcp__github__list_issues`	List repository issues

Workflow

Determine action: Create, update, or query?
Gather context: Get repo info, existing labels, milestones if needed
Structure content: Use appropriate template from references/templates.md
Execute: Call the appropriate MCP tool
Confirm: Report the issue URL to user

Creating Issues

Required Parameters

owner: repository owner (org or user)
repo: repository name 
title: clear, actionable title
body: structured markdown content

Optional Parameters

labels: ["bug", "enhancement", "documentation", ...]
assignees: ["username1", "username2"]
milestone: milestone number (integer)

Title Guidelines

Start with type prefix when useful: [Bug], [Feature], [Docs]
Be specific and actionable
Keep under 72 characters
Examples:
- [Bug] Login fails with SSO enabled
- [Feature] Add dark mode support
- Add unit tests for auth module

Body Structure

Always use the templates in references/templates.md. Choose based on issue type:

Github Multi Repo

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

GitHub Multi-Repository Coordination Skill

Overview

Advanced multi-repository coordination system that combines swarm intelligence, package synchronization, and repository architecture optimization. This skill enables organization-wide automation, cross-project collaboration, and scalable repository management.

Core Capabilities

🔄 Multi-Repository Swarm Coordination

Cross-repository AI swarm orchestration for distributed development workflows.

📦 Package Synchronization

Intelligent dependency resolution and version alignment across multiple packages.

🏗️ Repository Architecture

Structure optimization and template management for scalable projects.

🔗 Integration Management

Cross-package integration testing and deployment coordination.

GitHub Project Management

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

GitHub Project Management

Overview

A comprehensive skill for managing GitHub projects using AI swarm coordination. This skill combines intelligent issue management, automated project board synchronization, and swarm-based coordination for efficient project delivery.

Quick Start

Basic Issue Creation with Swarm Coordination

1# Create a coordinated issue
2gh issue create \
3 --title "Feature: Advanced Authentication" \
4 --body "Implement OAuth2 with social login..." \
5 --label "enhancement,swarm-ready"
6
7# Initialize swarm for issue
8npx claude-flow@alpha hooks pre-task --description "Feature implementation"

Project Board Quick Setup

1# Get project ID
2PROJECT_ID=$(gh project list --owner @me --format json | \
3 jq -r '.projects[0].id')
4
5# Initialize board sync
6npx ruv-swarm github board-init \
7 --project-id "$PROJECT_ID" \
8 --sync-mode "bidirectional"

Core Capabilities

1. Issue Management & Triage

Automated Issue Creation

Single Issue with Swarm Coordination

 1// Initialize issue management swarm
 2mcp__claude-flow__swarm_init { topology: "star", maxAgents: 3 }
 3mcp__claude-flow__agent_spawn { type: "coordinator", name: "Issue Coordinator" }
 4mcp__claude-flow__agent_spawn { type: "researcher", name: "Requirements Analyst" }
 5mcp__claude-flow__agent_spawn { type: "coder", name: "Implementation Planner" }
 6
 7// Create comprehensive issue
 8mcp__github__create_issue {
 9 owner: "org",
10 repo: "repository",
11 title: "Integration Review: Complete system integration",
12 body: `## 🔄 Integration Review
13
14 ### Overview
15 Comprehensive review and integration between components.
16
17 ### Objectives
18 - [ ] Verify dependencies and imports
19 - [ ] Ensure API integration
20 - [ ] Check hook system integration
21 - [ ] Validate data systems alignment
22
23 ### Swarm Coordination
24 This issue will be managed by coordinated swarm agents for optimal progress tracking.`,
25 labels: ["integration", "review", "enhancement"],
26 assignees: ["username"]
27}
28
29// Set up automated tracking
30mcp__claude-flow__task_orchestrate {
31 task: "Monitor and coordinate issue progress with automated updates",
32 strategy: "adaptive",
33 priority: "medium"
34}

Batch Issue Creation

 1# Create multiple related issues using gh CLI
 2gh issue create \
 3 --title "Feature: Advanced GitHub Integration" \
 4 --body "Implement comprehensive GitHub workflow automation..." \
 5 --label "feature,github,high-priority"
 6
 7gh issue create \
 8 --title "Bug: Merge conflicts in integration branch" \
 9 --body "Resolve merge conflicts..." \
10 --label "bug,integration,urgent"
11
12gh issue create \
13 --title "Documentation: Update integration guides" \
14 --body "Update all documentation..." \
15 --label "documentation,integration"

Issue-to-Swarm Conversion

Transform Issues into Swarm Tasks

 1# Get issue details
 2ISSUE_DATA=$(gh issue view 456 --json title,body,labels,assignees,comments)
 3
 4# Create swarm from issue
 5npx ruv-swarm github issue-to-swarm 456 \
 6 --issue-data "$ISSUE_DATA" \
 7 --auto-decompose \
 8 --assign-agents
 9
10# Batch process multiple issues
11ISSUES=$(gh issue list --label "swarm-ready" --json number,title,body,labels)
12npx ruv-swarm github issues-batch \
13 --issues "$ISSUES" \
14 --parallel
15
16# Update issues with swarm status
17echo "$ISSUES" | jq -r '.[].number' | while read -r num; do
18 gh issue edit $num --add-label "swarm-processing"
19done

Issue Comment Commands

Execute swarm operations via issue comments:

Github Release Management

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

GitHub Release Management Skill

Intelligent release automation and orchestration using AI swarms for comprehensive software releases - from changelog generation to multi-platform deployment with rollback capabilities.

Quick Start

Simple Release Flow

 1# Plan and create a release
 2gh release create v2.0.0 \
 3 --draft \
 4 --generate-notes \
 5 --title "Release v2.0.0"
 6
 7# Orchestrate with swarm
 8npx claude-flow github release-create \
 9 --version "2.0.0" \
10 --build-artifacts \
11 --deploy-targets "npm,docker,github"

Full Automated Release

1# Initialize release swarm
2npx claude-flow swarm init --topology hierarchical
3
4# Execute complete release pipeline
5npx claude-flow sparc pipeline "Release v2.0.0 with full validation"

Core Capabilities

1. Release Planning & Version Management

Semantic version analysis and suggestion
Breaking change detection from commits
Release timeline generation
Multi-package version coordination

2. Automated Testing & Validation

Multi-stage test orchestration
Cross-platform compatibility testing
Performance regression detection
Security vulnerability scanning

3. Build & Deployment Orchestration

Multi-platform build coordination
Parallel artifact generation
Progressive deployment strategies
Automated rollback mechanisms

4. Documentation & Communication

Automated changelog generation
Release notes with categorization
Migration guide creation
Stakeholder notification

Progressive Disclosure: Level 1 - Basic Usage

Essential Release Commands

Create Release Draft

 1# Get last release tag
 2LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
 3
 4# Generate changelog from commits
 5CHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \
 6 --jq '.commits[].commit.message')
 7
 8# Create draft release
 9gh release create v2.0.0 \
10 --draft \
11 --title "Release v2.0.0" \
12 --notes "$CHANGELOG" \
13 --target main

Basic Version Bump

1# Update package.json version
2npm version patch # or minor, major
3
4# Push version tag
5git push --follow-tags

Simple Deployment

1# Build and publish npm package
2npm run build
3npm publish
4
5# Create GitHub release
6gh release create $(npm pkg get version) \
7 --generate-notes

Quick Integration Example

 1// Simple release preparation in Claude Code
 2[Single Message]:
 3 // Update version files
 4 Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })
 5
 6 // Generate changelog
 7 Bash("gh api repos/:owner/:repo/compare/v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")
 8
 9 // Create release branch
10 Bash("git checkout -b release/v2.0.0")
11 Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")
12
13 // Create PR
14 Bash("gh pr create --title 'Release v2.0.0' --body 'Automated release preparation'")

Progressive Disclosure: Level 2 - Swarm Coordination

AI Swarm Release Orchestration

Initialize Release Swarm

 1// Set up coordinated release team
 2[Single Message - Swarm Initialization]:
 3 mcp__claude-flow__swarm_init {
 4 topology: "hierarchical",
 5 maxAgents: 6,
 6 strategy: "balanced"
 7 }
 8
 9 // Spawn specialized agents
10 mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }
11 mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }
12 mcp__claude-flow__agent_spawn { type: "tester", name: "测试工程师" }
13 mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }
14 mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }
15 mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }

Coordinated Release Workflow

 1[Single Message - Full Release Coordination]:
 2 // Create release branch
 3 Bash("gh api repos/:owner/:repo/git/refs --method POST -f ref='refs/heads/release/v2.0.0' -f sha=$(gh api repos/:owner/:repo/git/refs/heads/main --jq '.object.sha')")
 4
 5 // Orchestrate release preparation
 6 mcp__claude-flow__task_orchestrate {
 7 task: "Prepare release v2.0.0 with comprehensive testing and validation",
 8 strategy: "sequential",
 9 priority: "critical",
10 maxAgents: 6
11 }
12
13 // Update all release files
14 Write("package.json", "[updated version]")
15 Write("CHANGELOG.md", "[release changelog]")
16 Write("RELEASE_NOTES.md", "[detailed notes]")
17
18 // Run comprehensive validation
19 Bash("npm install && npm test && npm run lint && npm run build")
20
21 // Create release PR
22 Bash(`gh pr create \
23 --title "Release v2.0.0: Feature Set and Improvements" \
24 --head "release/v2.0.0" \
25 --base "main" \
26 --body "$(cat RELEASE_NOTES.md)"`)
27
28 // Track progress
29 TodoWrite { todos: [
30 { content: "Prepare release branch", status: "completed", priority: "critical" },
31 { content: "Run validation suite", status: "completed", priority: "high" },
32 { content: "Create release PR", status: "completed", priority: "high" },
33 { content: "Code review approval", status: "pending", priority: "high" },
34 { content: "Merge and deploy", status: "pending", priority: "critical" }
35 ]}
36
37 // Store release state
38 mcp__claude-flow__memory_usage {
39 action: "store",
40 key: "release/v2.0.0/status",
41 value: JSON.stringify({
42 version: "2.0.0",
43 stage: "validation_complete",
44 timestamp: Date.now(),
45 ready_for_review: true
46 })
47 }

Release Agent Specializations

Changelog Agent

 1# Get merged PRs between versions
 2PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
 3 --jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")
 4
 5# Get commit history
 6COMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \
 7 --jq '.commits[].commit.message')
 8
 9# Generate categorized changelog
10npx claude-flow github changelog \
11 --prs "$PRS" \
12 --commits "$COMMITS" \
13 --from v1.0.0 \
14 --to HEAD \
15 --categorize \
16 --add-migration-guide

Capabilities:

Github Workflow Automation

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

GitHub Workflow Automation Skill

Overview

This skill provides comprehensive GitHub Actions automation with AI swarm coordination. It integrates intelligent CI/CD pipelines, workflow orchestration, and repository management to create self-organizing, adaptive GitHub workflows.

Quick Start

💡 Basic Usage - Click to expand

Initialize GitHub Workflow Automation

1# Start with a simple workflow
2npx ruv-swarm actions generate-workflow \
3 --analyze-codebase \
4 --detect-languages \
5 --create-optimal-pipeline

Common Commands

1# Optimize existing workflow
2npx ruv-swarm actions optimize \
3 --workflow ".github/workflows/ci.yml" \
4 --suggest-parallelization
5
6# Analyze failed runs
7gh run view <run-id> --json jobs,conclusion | \
8 npx ruv-swarm actions analyze-failure \
9 --suggest-fixes

Core Capabilities

🤖 Swarm-Powered GitHub Modes

Available GitHub Integration Modes

1. gh-coordinator

GitHub workflow orchestration and coordination

Gitlab Ci Patterns

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

GitLab CI Patterns

Comprehensive GitLab CI/CD pipeline patterns for automated testing, building, and deployment.

Purpose

Create efficient GitLab CI pipelines with proper stage organization, caching, and deployment strategies.

When to Use

Automate GitLab-based CI/CD
Implement multi-stage pipelines
Configure GitLab Runners
Deploy to Kubernetes from GitLab
Implement GitOps workflows

Basic Pipeline Structure

 1stages:
 2 - build
 3 - test
 4 - deploy
 5
 6variables:
 7 DOCKER_DRIVER: overlay2
 8 DOCKER_TLS_CERTDIR: "/certs"
 9
10build:
11 stage: build
12 image: node:20
13 script:
14 - npm ci
15 - npm run build
16 artifacts:
17 paths:
18 - dist/
19 expire_in: 1 hour
20 cache:
21 key: ${CI_COMMIT_REF_SLUG}
22 paths:
23 - node_modules/
24
25test:
26 stage: test
27 image: node:20
28 script:
29 - npm ci
30 - npm run lint
31 - npm test
32 coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
33 artifacts:
34 reports:
35 coverage_report:
36 coverage_format: cobertura
37 path: coverage/cobertura-coverage.xml
38
39deploy:
40 stage: deploy
41 image: bitnami/kubectl:latest
42 script:
43 - kubectl apply -f k8s/
44 - kubectl rollout status deployment/my-app
45 only:
46 - main
47 environment:
48 name: production
49 url: https://app.example.com

Docker Build and Push

 1build-docker:
 2 stage: build
 3 image: docker:24
 4 services:
 5 - docker:24-dind
 6 before_script:
 7 - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
 8 script:
 9 - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
10 - docker build -t $CI_REGISTRY_IMAGE:latest .
11 - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
12 - docker push $CI_REGISTRY_IMAGE:latest
13 only:
14 - main
15 - tags

Multi-Environment Deployment

 1.deploy_template: &deploy_template
 2 image: bitnami/kubectl:latest
 3 before_script:
 4 - kubectl config set-cluster k8s --server="$KUBE_URL" --insecure-skip-tls-verify=true
 5 - kubectl config set-credentials admin --token="$KUBE_TOKEN"
 6 - kubectl config set-context default --cluster=k8s --user=admin
 7 - kubectl config use-context default
 8
 9deploy:staging:
10 <<: *deploy_template
11 stage: deploy
12 script:
13 - kubectl apply -f k8s/ -n staging
14 - kubectl rollout status deployment/my-app -n staging
15 environment:
16 name: staging
17 url: https://staging.example.com
18 only:
19 - develop
20
21deploy:production:
22 <<: *deploy_template
23 stage: deploy
24 script:
25 - kubectl apply -f k8s/ -n production
26 - kubectl rollout status deployment/my-app -n production
27 environment:
28 name: production
29 url: https://app.example.com
30 when: manual
31 only:
32 - main

Terraform Pipeline

 1stages:
 2 - validate
 3 - plan
 4 - apply
 5
 6variables:
 7 TF_ROOT: ${CI_PROJECT_DIR}/terraform
 8 TF_VERSION: "1.6.0"
 9
10before_script:
11 - cd ${TF_ROOT}
12 - terraform --version
13
14validate:
15 stage: validate
16 image: hashicorp/terraform:${TF_VERSION}
17 script:
18 - terraform init -backend=false
19 - terraform validate
20 - terraform fmt -check
21
22plan:
23 stage: plan
24 image: hashicorp/terraform:${TF_VERSION}
25 script:
26 - terraform init
27 - terraform plan -out=tfplan
28 artifacts:
29 paths:
30 - ${TF_ROOT}/tfplan
31 expire_in: 1 day
32
33apply:
34 stage: apply
35 image: hashicorp/terraform:${TF_VERSION}
36 script:
37 - terraform init
38 - terraform apply -auto-approve tfplan
39 dependencies:
40 - plan
41 when: manual
42 only:
43 - main

Security Scanning

 1include:
 2 - template: Security/SAST.gitlab-ci.yml
 3 - template: Security/Dependency-Scanning.gitlab-ci.yml
 4 - template: Security/Container-Scanning.gitlab-ci.yml
 5
 6trivy-scan:
 7 stage: test
 8 image: aquasec/trivy:latest
 9 script:
10 - trivy image --exit-code 1 --severity HIGH,CRITICAL $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
11 allow_failure: true

Caching Strategies

 1# Cache node_modules
 2build:
 3 cache:
 4 key: ${CI_COMMIT_REF_SLUG}
 5 paths:
 6 - node_modules/
 7 policy: pull-push
 8
 9# Global cache
10cache:
11 key: ${CI_COMMIT_REF_SLUG}
12 paths:
13 - .cache/
14 - vendor/
15
16# Separate cache per job
17job1:
18 cache:
19 key: job1-cache
20 paths:
21 - build/
22
23job2:
24 cache:
25 key: job2-cache
26 paths:
27 - dist/

Dynamic Child Pipelines

 1generate-pipeline:
 2 stage: build
 3 script:
 4 - python generate_pipeline.py > child-pipeline.yml
 5 artifacts:
 6 paths:
 7 - child-pipeline.yml
 8
 9trigger-child:
10 stage: deploy
11 trigger:
12 include:
13 - artifact: child-pipeline.yml
14 job: generate-pipeline
15 strategy: depend

Reference Files

assets/gitlab-ci.yml.template - Complete pipeline template
references/pipeline-stages.md - Stage organization patterns

Best Practices

Use specific image tags (node:20, not node:latest)
Cache dependencies appropriately
Use artifacts for build outputs
Implement manual gates for production
Use environments for deployment tracking
Enable merge request pipelines
Use pipeline schedules for recurring jobs
Implement security scanning
Use CI/CD variables for secrets
Monitor pipeline performance

github-actions-templates - For GitHub Actions
deployment-pipeline-design - For architecture
secrets-management - For secrets handling

Go Concurrency Patterns

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

Go Concurrency Patterns

Production patterns for Go concurrency including goroutines, channels, synchronization primitives, and context management.

When to Use This Skill

Building concurrent Go applications
Implementing worker pools and pipelines
Managing goroutine lifecycles
Using channels for communication
Debugging race conditions
Implementing graceful shutdown

Core Concepts

1. Go Concurrency Primitives

Primitive	Purpose
`goroutine`	Lightweight concurrent execution
`channel`	Communication between goroutines
`select`	Multiplex channel operations
`sync.Mutex`	Mutual exclusion
`sync.WaitGroup`	Wait for goroutines to complete
`context.Context`	Cancellation and deadlines

2. Go Concurrency Mantra

Don't communicate by sharing memory;
share memory by communicating.

Quick Start

 1package main
 2
 3import (
 4 "context"
 5 "fmt"
 6 "sync"
 7 "time"
 8)
 9
10func main() {
11 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
12 defer cancel()
13
14 results := make(chan string, 10)
15 var wg sync.WaitGroup
16
17 // Spawn workers
18 for i := 0; i < 3; i++ {
19 wg.Add(1)
20 go worker(ctx, i, results, &wg)
21 }
22
23 // Close results when done
24 go func() {
25 wg.Wait()
26 close(results)
27 }()
28
29 // Collect results
30 for result := range results {
31 fmt.Println(result)
32 }
33}
34
35func worker(ctx context.Context, id int, results chan<- string, wg *sync.WaitGroup) {
36 defer wg.Done()
37
38 select {
39 case <-ctx.Done():
40 return
41 case results <- fmt.Sprintf("Worker %d done", id):
42 }
43}

Patterns

Pattern 1: Worker Pool

 1package main
 2
 3import (
 4 "context"
 5 "fmt"
 6 "sync"
 7)
 8
 9type Job struct {
10 ID int
11 Data string
12}
13
14type Result struct {
15 JobID int
16 Output string
17 Err error
18}
19
20func WorkerPool(ctx context.Context, numWorkers int, jobs <-chan Job) <-chan Result {
21 results := make(chan Result, len(jobs))
22
23 var wg sync.WaitGroup
24 for i := 0; i < numWorkers; i++ {
25 wg.Add(1)
26 go func(workerID int) {
27 defer wg.Done()
28 for job := range jobs {
29 select {
30 case <-ctx.Done():
31 return
32 default:
33 result := processJob(job)
34 results <- result
35 }
36 }
37 }(i)
38 }
39
40 go func() {
41 wg.Wait()
42 close(results)
43 }()
44
45 return results
46}
47
48func processJob(job Job) Result {
49 // Simulate work
50 return Result{
51 JobID: job.ID,
52 Output: fmt.Sprintf("Processed: %s", job.Data),
53 }
54}
55
56// Usage
57func main() {
58 ctx, cancel := context.WithCancel(context.Background())
59 defer cancel()
60
61 jobs := make(chan Job, 100)
62
63 // Send jobs
64 go func() {
65 for i := 0; i < 50; i++ {
66 jobs <- Job{ID: i, Data: fmt.Sprintf("job-%d", i)}
67 }
68 close(jobs)
69 }()
70
71 // Process with 5 workers
72 results := WorkerPool(ctx, 5, jobs)
73
74 for result := range results {
75 fmt.Printf("Result: %+v\n", result)
76 }
77}

Pattern 2: Fan-Out/Fan-In Pipeline

 1package main
 2
 3import (
 4 "context"
 5 "sync"
 6)
 7
 8// Stage 1: Generate numbers
 9func generate(ctx context.Context, nums ...int) <-chan int {
10 out := make(chan int)
11 go func() {
12 defer close(out)
13 for _, n := range nums {
14 select {
15 case <-ctx.Done():
16 return
17 case out <- n:
18 }
19 }
20 }()
21 return out
22}
23
24// Stage 2: Square numbers (can run multiple instances)
25func square(ctx context.Context, in <-chan int) <-chan int {
26 out := make(chan int)
27 go func() {
28 defer close(out)
29 for n := range in {
30 select {
31 case <-ctx.Done():
32 return
33 case out <- n * n:
34 }
35 }
36 }()
37 return out
38}
39
40// Fan-in: Merge multiple channels into one
41func merge(ctx context.Context, cs ...<-chan int) <-chan int {
42 var wg sync.WaitGroup
43 out := make(chan int)
44
45 // Start output goroutine for each input channel
46 output := func(c <-chan int) {
47 defer wg.Done()
48 for n := range c {
49 select {
50 case <-ctx.Done():
51 return
52 case out <- n:
53 }
54 }
55 }
56
57 wg.Add(len(cs))
58 for _, c := range cs {
59 go output(c)
60 }
61
62 // Close out after all inputs are done
63 go func() {
64 wg.Wait()
65 close(out)
66 }()
67
68 return out
69}
70
71func main() {
72 ctx, cancel := context.WithCancel(context.Background())
73 defer cancel()
74
75 // Generate input
76 in := generate(ctx, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
77
78 // Fan out to multiple squarers
79 c1 := square(ctx, in)
80 c2 := square(ctx, in)
81 c3 := square(ctx, in)
82
83 // Fan in results
84 for result := range merge(ctx, c1, c2, c3) {
85 fmt.Println(result)
86 }
87}

Pattern 3: Bounded Concurrency with Semaphore

 1package main
 2
 3import (
 4 "context"
 5 "fmt"
 6 "golang.org/x/sync/semaphore"
 7 "sync"
 8)
 9
10type RateLimitedWorker struct {
11 sem *semaphore.Weighted
12}
13
14func NewRateLimitedWorker(maxConcurrent int64) *RateLimitedWorker {
15 return &RateLimitedWorker{
16 sem: semaphore.NewWeighted(maxConcurrent),
17 }
18}
19
20func (w *RateLimitedWorker) Do(ctx context.Context, tasks []func() error) []error {
21 var (
22 wg sync.WaitGroup
23 mu sync.Mutex
24 errors []error
25 )
26
27 for _, task := range tasks {
28 // Acquire semaphore (blocks if at limit)
29 if err := w.sem.Acquire(ctx, 1); err != nil {
30 return []error{err}
31 }
32
33 wg.Add(1)
34 go func(t func() error) {
35 defer wg.Done()
36 defer w.sem.Release(1)
37
38 if err := t(); err != nil {
39 mu.Lock()
40 errors = append(errors, err)
41 mu.Unlock()
42 }
43 }(task)
44 }
45
46 wg.Wait()
47 return errors
48}
49
50// Alternative: Channel-based semaphore
51type Semaphore chan struct{}
52
53func NewSemaphore(n int) Semaphore {
54 return make(chan struct{}, n)
55}
56
57func (s Semaphore) Acquire() {
58 s <- struct{}{}
59}
60
61func (s Semaphore) Release() {
62 <-s
63}

Pattern 4: Graceful Shutdown

 1package main
 2
 3import (
 4 "context"
 5 "fmt"
 6 "os"
 7 "os/signal"
 8 "sync"
 9 "syscall"
10 "time"
11)
12
13type Server struct {
14 shutdown chan struct{}
15 wg sync.WaitGroup
16}
17
18func NewServer() *Server {
19 return &Server{
20 shutdown: make(chan struct{}),
21 }
22}
23
24func (s *Server) Start(ctx context.Context) {
25 // Start workers
26 for i := 0; i < 5; i++ {
27 s.wg.Add(1)
28 go s.worker(ctx, i)
29 }
30}
31
32func (s *Server) worker(ctx context.Context, id int) {
33 defer s.wg.Done()
34 defer fmt.Printf("Worker %d stopped\n", id)
35
36 ticker := time.NewTicker(time.Second)
37 defer ticker.Stop()
38
39 for {
40 select {
41 case <-ctx.Done():
42 // Cleanup
43 fmt.Printf("Worker %d cleaning up...\n", id)
44 time.Sleep(500 * time.Millisecond) // Simulated cleanup
45 return
46 case <-ticker.C:
47 fmt.Printf("Worker %d working...\n", id)
48 }
49 }
50}
51
52func (s *Server) Shutdown(timeout time.Duration) {
53 // Signal shutdown
54 close(s.shutdown)
55
56 // Wait with timeout
57 done := make(chan struct{})
58 go func() {
59 s.wg.Wait()
60 close(done)
61 }()
62
63 select {
64 case <-done:
65 fmt.Println("Clean shutdown completed")
66 case <-time.After(timeout):
67 fmt.Println("Shutdown timed out, forcing exit")
68 }
69}
70
71func main() {
72 // Setup signal handling
73 ctx, cancel := context.WithCancel(context.Background())
74
75 sigCh := make(chan os.Signal, 1)
76 signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
77
78 server := NewServer()
79 server.Start(ctx)
80
81 // Wait for signal
82 sig := <-sigCh
83 fmt.Printf("\nReceived signal: %v\n", sig)
84
85 // Cancel context to stop workers
86 cancel()
87
88 // Wait for graceful shutdown
89 server.Shutdown(5 * time.Second)
90}

Pattern 5: Error Group with Cancellation

 1package main
 2
 3import (
 4 "context"
 5 "fmt"
 6 "golang.org/x/sync/errgroup"
 7 "net/http"
 8)
 9
10func fetchAllURLs(ctx context.Context, urls []string) ([]string, error) {
11 g, ctx := errgroup.WithContext(ctx)
12
13 results := make([]string, len(urls))
14
15 for i, url := range urls {
16 i, url := i, url // Capture loop variables
17
18 g.Go(func() error {
19 req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
20 if err != nil {
21 return fmt.Errorf("creating request for %s: %w", url, err)
22 }
23
24 resp, err := http.DefaultClient.Do(req)
25 if err != nil {
26 return fmt.Errorf("fetching %s: %w", url, err)
27 }
28 defer resp.Body.Close()
29
30 results[i] = fmt.Sprintf("%s: %d", url, resp.StatusCode)
31 return nil
32 })
33 }
34
35 // Wait for all goroutines to complete or one to fail
36 if err := g.Wait(); err != nil {
37 return nil, err // First error cancels all others
38 }
39
40 return results, nil
41}
42
43// With concurrency limit
44func fetchWithLimit(ctx context.Context, urls []string, limit int) ([]string, error) {
45 g, ctx := errgroup.WithContext(ctx)
46 g.SetLimit(limit) // Max concurrent goroutines
47
48 results := make([]string, len(urls))
49 var mu sync.Mutex
50
51 for i, url := range urls {
52 i, url := i, url
53
54 g.Go(func() error {
55 result, err := fetchURL(ctx, url)
56 if err != nil {
57 return err
58 }
59
60 mu.Lock()
61 results[i] = result
62 mu.Unlock()
63 return nil
64 })
65 }
66
67 if err := g.Wait(); err != nil {
68 return nil, err
69 }
70
71 return results, nil
72}

Pattern 6: Concurrent Map with sync.Map

 1package main
 2
 3import (
 4 "sync"
 5)
 6
 7// For frequent reads, infrequent writes
 8type Cache struct {
 9 m sync.Map
10}
11
12func (c *Cache) Get(key string) (interface{}, bool) {
13 return c.m.Load(key)
14}
15
16func (c *Cache) Set(key string, value interface{}) {
17 c.m.Store(key, value)
18}
19
20func (c *Cache) GetOrSet(key string, value interface{}) (interface{}, bool) {
21 return c.m.LoadOrStore(key, value)
22}
23
24func (c *Cache) Delete(key string) {
25 c.m.Delete(key)
26}
27
28// For write-heavy workloads, use sharded map
29type ShardedMap struct {
30 shards []*shard
31 numShards int
32}
33
34type shard struct {
35 sync.RWMutex
36 data map[string]interface{}
37}
38
39func NewShardedMap(numShards int) *ShardedMap {
40 m := &ShardedMap{
41 shards: make([]*shard, numShards),
42 numShards: numShards,
43 }
44 for i := range m.shards {
45 m.shards[i] = &shard{data: make(map[string]interface{})}
46 }
47 return m
48}
49
50func (m *ShardedMap) getShard(key string) *shard {
51 // Simple hash
52 h := 0
53 for _, c := range key {
54 h = 31*h + int(c)
55 }
56 return m.shards[h%m.numShards]
57}
58
59func (m *ShardedMap) Get(key string) (interface{}, bool) {
60 shard := m.getShard(key)
61 shard.RLock()
62 defer shard.RUnlock()
63 v, ok := shard.data[key]
64 return v, ok
65}
66
67func (m *ShardedMap) Set(key string, value interface{}) {
68 shard := m.getShard(key)
69 shard.Lock()
70 defer shard.Unlock()
71 shard.data[key] = value
72}

Pattern 7: Select with Timeout and Default

 1func selectPatterns() {
 2 ch := make(chan int)
 3
 4 // Timeout pattern
 5 select {
 6 case v := <-ch:
 7 fmt.Println("Received:", v)
 8 case <-time.After(time.Second):
 9 fmt.Println("Timeout!")
10 }
11
12 // Non-blocking send/receive
13 select {
14 case ch <- 42:
15 fmt.Println("Sent")
16 default:
17 fmt.Println("Channel full, skipping")
18 }
19
20 // Priority select (check high priority first)
21 highPriority := make(chan int)
22 lowPriority := make(chan int)
23
24 for {
25 select {
26 case msg := <-highPriority:
27 fmt.Println("High priority:", msg)
28 default:
29 select {
30 case msg := <-highPriority:
31 fmt.Println("High priority:", msg)
32 case msg := <-lowPriority:
33 fmt.Println("Low priority:", msg)
34 }
35 }
36 }
37}

Race Detection

1# Run tests with race detector
2go test -race ./...
3
4# Build with race detector
5go build -race .
6
7# Run with race detector
8go run -race main.go

Best Practices

Do’s

Use context - For cancellation and deadlines
Close channels - From sender side only
Use errgroup - For concurrent operations with errors
Buffer channels - When you know the count
Prefer channels - Over mutexes when possible

Don’ts

Don’t leak goroutines - Always have exit path
Don’t close from receiver - Causes panic
Don’t use shared memory - Unless necessary
Don’t ignore context cancellation - Check ctx.Done()
Don’t use time.Sleep for sync - Use proper primitives

Resources

Godot Gdscript Patterns

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

Godot GDScript Patterns

Production patterns for Godot 4.x game development with GDScript, covering architecture, signals, scenes, and optimization.

When to Use This Skill

Building games with Godot 4
Implementing game systems in GDScript
Designing scene architecture
Managing game state
Optimizing GDScript performance
Learning Godot best practices

Core Concepts

1. Godot Architecture

Node: Base building block
├── Scene: Reusable node tree (saved as .tscn)
├── Resource: Data container (saved as .tres)
├── Signal: Event communication
└── Group: Node categorization

2. GDScript Basics

 1class_name Player
 2extends CharacterBody2D
 3
 4# Signals
 5signal health_changed(new_health: int)
 6signal died
 7
 8# Exports (Inspector-editable)
 9@export var speed: float = 200.0
10@export var max_health: int = 100
11@export_range(0, 1) var damage_reduction: float = 0.0
12@export_group("Combat")
13@export var attack_damage: int = 10
14@export var attack_cooldown: float = 0.5
15
16# Onready (initialized when ready)
17@onready var sprite: Sprite2D = $Sprite2D
18@onready var animation: AnimationPlayer = $AnimationPlayer
19@onready var hitbox: Area2D = $Hitbox
20
21# Private variables (convention: underscore prefix)
22var _health: int
23var _can_attack: bool = true
24
25func _ready() -> void:
26 _health = max_health
27
28func _physics_process(delta: float) -> void:
29 var direction := Input.get_vector("left", "right", "up", "down")
30 velocity = direction * speed
31 move_and_slide()
32
33func take_damage(amount: int) -> void:
34 var actual_damage := int(amount * (1.0 - damage_reduction))
35 _health = max(_health - actual_damage, 0)
36 health_changed.emit(_health)
37
38 if _health <= 0:
39 died.emit()

Patterns

Pattern 1: State Machine

 1# state_machine.gd
 2class_name StateMachine
 3extends Node
 4
 5signal state_changed(from_state: StringName, to_state: StringName)
 6
 7@export var initial_state: State
 8
 9var current_state: State
10var states: Dictionary = {}
11
12func _ready() -> void:
13 # Register all State children
14 for child in get_children():
15 if child is State:
16 states[child.name] = child
17 child.state_machine = self
18 child.process_mode = Node.PROCESS_MODE_DISABLED
19
20 # Start initial state
21 if initial_state:
22 current_state = initial_state
23 current_state.process_mode = Node.PROCESS_MODE_INHERIT
24 current_state.enter()
25
26func _process(delta: float) -> void:
27 if current_state:
28 current_state.update(delta)
29
30func _physics_process(delta: float) -> void:
31 if current_state:
32 current_state.physics_update(delta)
33
34func _unhandled_input(event: InputEvent) -> void:
35 if current_state:
36 current_state.handle_input(event)
37
38func transition_to(state_name: StringName, msg: Dictionary = {}) -> void:
39 if not states.has(state_name):
40 push_error("State '%s' not found" % state_name)
41 return
42
43 var previous_state := current_state
44 previous_state.exit()
45 previous_state.process_mode = Node.PROCESS_MODE_DISABLED
46
47 current_state = states[state_name]
48 current_state.process_mode = Node.PROCESS_MODE_INHERIT
49 current_state.enter(msg)
50
51 state_changed.emit(previous_state.name, current_state.name)

 1# state.gd
 2class_name State
 3extends Node
 4
 5var state_machine: StateMachine
 6
 7func enter(_msg: Dictionary = {}) -> void:
 8 pass
 9
10func exit() -> void:
11 pass
12
13func update(_delta: float) -> void:
14 pass
15
16func physics_update(_delta: float) -> void:
17 pass
18
19func handle_input(_event: InputEvent) -> void:
20 pass

 1# player_idle.gd
 2class_name PlayerIdle
 3extends State
 4
 5@export var player: Player
 6
 7func enter(_msg: Dictionary = {}) -> void:
 8 player.animation.play("idle")
 9
10func physics_update(_delta: float) -> void:
11 var direction := Input.get_vector("left", "right", "up", "down")
12
13 if direction != Vector2.ZERO:
14 state_machine.transition_to("Move")
15
16func handle_input(event: InputEvent) -> void:
17 if event.is_action_pressed("attack"):
18 state_machine.transition_to("Attack")
19 elif event.is_action_pressed("jump"):
20 state_machine.transition_to("Jump")

Pattern 2: Autoload Singletons

 1# game_manager.gd (Add to Project Settings > Autoload)
 2extends Node
 3
 4signal game_started
 5signal game_paused(is_paused: bool)
 6signal game_over(won: bool)
 7signal score_changed(new_score: int)
 8
 9enum GameState { MENU, PLAYING, PAUSED, GAME_OVER }
10
11var state: GameState = GameState.MENU
12var score: int = 0:
13 set(value):
14 score = value
15 score_changed.emit(score)
16
17var high_score: int = 0
18
19func _ready() -> void:
20 process_mode = Node.PROCESS_MODE_ALWAYS
21 _load_high_score()
22
23func _input(event: InputEvent) -> void:
24 if event.is_action_pressed("pause") and state == GameState.PLAYING:
25 toggle_pause()
26
27func start_game() -> void:
28 score = 0
29 state = GameState.PLAYING
30 game_started.emit()
31
32func toggle_pause() -> void:
33 var is_paused := state != GameState.PAUSED
34
35 if is_paused:
36 state = GameState.PAUSED
37 get_tree().paused = true
38 else:
39 state = GameState.PLAYING
40 get_tree().paused = false
41
42 game_paused.emit(is_paused)
43
44func end_game(won: bool) -> void:
45 state = GameState.GAME_OVER
46
47 if score > high_score:
48 high_score = score
49 _save_high_score()
50
51 game_over.emit(won)
52
53func add_score(points: int) -> void:
54 score += points
55
56func _load_high_score() -> void:
57 if FileAccess.file_exists("user://high_score.save"):
58 var file := FileAccess.open("user://high_score.save", FileAccess.READ)
59 high_score = file.get_32()
60
61func _save_high_score() -> void:
62 var file := FileAccess.open("user://high_score.save", FileAccess.WRITE)
63 file.store_32(high_score)

 1# event_bus.gd (Global signal bus)
 2extends Node
 3
 4# Player events
 5signal player_spawned(player: Node2D)
 6signal player_died(player: Node2D)
 7signal player_health_changed(health: int, max_health: int)
 8
 9# Enemy events
10signal enemy_spawned(enemy: Node2D)
11signal enemy_died(enemy: Node2D, position: Vector2)
12
13# Item events
14signal item_collected(item_type: StringName, value: int)
15signal powerup_activated(powerup_type: StringName)
16
17# Level events
18signal level_started(level_number: int)
19signal level_completed(level_number: int, time: float)
20signal checkpoint_reached(checkpoint_id: int)

Pattern 3: Resource-based Data

 1# weapon_data.gd
 2class_name WeaponData
 3extends Resource
 4
 5@export var name: StringName
 6@export var damage: int
 7@export var attack_speed: float
 8@export var range: float
 9@export_multiline var description: String
10@export var icon: Texture2D
11@export var projectile_scene: PackedScene
12@export var sound_attack: AudioStream

 1# character_stats.gd
 2class_name CharacterStats
 3extends Resource
 4
 5signal stat_changed(stat_name: StringName, new_value: float)
 6
 7@export var max_health: float = 100.0
 8@export var attack: float = 10.0
 9@export var defense: float = 5.0
10@export var speed: float = 200.0
11
12# Runtime values (not saved)
13var _current_health: float
14
15func _init() -> void:
16 _current_health = max_health
17
18func get_current_health() -> float:
19 return _current_health
20
21func take_damage(amount: float) -> float:
22 var actual_damage := maxf(amount - defense, 1.0)
23 _current_health = maxf(_current_health - actual_damage, 0.0)
24 stat_changed.emit("health", _current_health)
25 return actual_damage
26
27func heal(amount: float) -> void:
28 _current_health = minf(_current_health + amount, max_health)
29 stat_changed.emit("health", _current_health)
30
31func duplicate_for_runtime() -> CharacterStats:
32 var copy := duplicate() as CharacterStats
33 copy._current_health = copy.max_health
34 return copy

 1# Using resources
 2class_name Character
 3extends CharacterBody2D
 4
 5@export var base_stats: CharacterStats
 6@export var weapon: WeaponData
 7
 8var stats: CharacterStats
 9
10func _ready() -> void:
11 # Create runtime copy to avoid modifying the resource
12 stats = base_stats.duplicate_for_runtime()
13 stats.stat_changed.connect(_on_stat_changed)
14
15func attack() -> void:
16 if weapon:
17 print("Attacking with %s for %d damage" % [weapon.name, weapon.damage])
18
19func _on_stat_changed(stat_name: StringName, value: float) -> void:
20 if stat_name == "health" and value <= 0:
21 die()

Pattern 4: Object Pooling

 1# object_pool.gd
 2class_name ObjectPool
 3extends Node
 4
 5@export var pooled_scene: PackedScene
 6@export var initial_size: int = 10
 7@export var can_grow: bool = true
 8
 9var _available: Array[Node] = []
10var _in_use: Array[Node] = []
11
12func _ready() -> void:
13 _initialize_pool()
14
15func _initialize_pool() -> void:
16 for i in initial_size:
17 _create_instance()
18
19func _create_instance() -> Node:
20 var instance := pooled_scene.instantiate()
21 instance.process_mode = Node.PROCESS_MODE_DISABLED
22 instance.visible = false
23 add_child(instance)
24 _available.append(instance)
25
26 # Connect return signal if exists
27 if instance.has_signal("returned_to_pool"):
28 instance.returned_to_pool.connect(_return_to_pool.bind(instance))
29
30 return instance
31
32func get_instance() -> Node:
33 var instance: Node
34
35 if _available.is_empty():
36 if can_grow:
37 instance = _create_instance()
38 _available.erase(instance)
39 else:
40 push_warning("Pool exhausted and cannot grow")
41 return null
42 else:
43 instance = _available.pop_back()
44
45 instance.process_mode = Node.PROCESS_MODE_INHERIT
46 instance.visible = true
47 _in_use.append(instance)
48
49 if instance.has_method("on_spawn"):
50 instance.on_spawn()
51
52 return instance
53
54func _return_to_pool(instance: Node) -> void:
55 if not instance in _in_use:
56 return
57
58 _in_use.erase(instance)
59
60 if instance.has_method("on_despawn"):
61 instance.on_despawn()
62
63 instance.process_mode = Node.PROCESS_MODE_DISABLED
64 instance.visible = false
65 _available.append(instance)
66
67func return_all() -> void:
68 for instance in _in_use.duplicate():
69 _return_to_pool(instance)

 1# pooled_bullet.gd
 2class_name PooledBullet
 3extends Area2D
 4
 5signal returned_to_pool
 6
 7@export var speed: float = 500.0
 8@export var lifetime: float = 5.0
 9
10var direction: Vector2
11var _timer: float
12
13func on_spawn() -> void:
14 _timer = lifetime
15
16func on_despawn() -> void:
17 direction = Vector2.ZERO
18
19func initialize(pos: Vector2, dir: Vector2) -> void:
20 global_position = pos
21 direction = dir.normalized()
22 rotation = direction.angle()
23
24func _physics_process(delta: float) -> void:
25 position += direction * speed * delta
26
27 _timer -= delta
28 if _timer <= 0:
29 returned_to_pool.emit()
30
31func _on_body_entered(body: Node2D) -> void:
32 if body.has_method("take_damage"):
33 body.take_damage(10)
34 returned_to_pool.emit()

Pattern 5: Component System

 1# health_component.gd
 2class_name HealthComponent
 3extends Node
 4
 5signal health_changed(current: int, maximum: int)
 6signal damaged(amount: int, source: Node)
 7signal healed(amount: int)
 8signal died
 9
10@export var max_health: int = 100
11@export var invincibility_time: float = 0.0
12
13var current_health: int:
14 set(value):
15 var old := current_health
16 current_health = clampi(value, 0, max_health)
17 if current_health != old:
18 health_changed.emit(current_health, max_health)
19
20var _invincible: bool = false
21
22func _ready() -> void:
23 current_health = max_health
24
25func take_damage(amount: int, source: Node = null) -> int:
26 if _invincible or current_health <= 0:
27 return 0
28
29 var actual := mini(amount, current_health)
30 current_health -= actual
31 damaged.emit(actual, source)
32
33 if current_health <= 0:
34 died.emit()
35 elif invincibility_time > 0:
36 _start_invincibility()
37
38 return actual
39
40func heal(amount: int) -> int:
41 var actual := mini(amount, max_health - current_health)
42 current_health += actual
43 if actual > 0:
44 healed.emit(actual)
45 return actual
46
47func _start_invincibility() -> void:
48 _invincible = true
49 await get_tree().create_timer(invincibility_time).timeout
50 _invincible = false

 1# hitbox_component.gd
 2class_name HitboxComponent
 3extends Area2D
 4
 5signal hit(hurtbox: HurtboxComponent)
 6
 7@export var damage: int = 10
 8@export var knockback_force: float = 200.0
 9
10var owner_node: Node
11
12func _ready() -> void:
13 owner_node = get_parent()
14 area_entered.connect(_on_area_entered)
15
16func _on_area_entered(area: Area2D) -> void:
17 if area is HurtboxComponent:
18 var hurtbox := area as HurtboxComponent
19 if hurtbox.owner_node != owner_node:
20 hit.emit(hurtbox)
21 hurtbox.receive_hit(self)

 1# hurtbox_component.gd
 2class_name HurtboxComponent
 3extends Area2D
 4
 5signal hurt(hitbox: HitboxComponent)
 6
 7@export var health_component: HealthComponent
 8
 9var owner_node: Node
10
11func _ready() -> void:
12 owner_node = get_parent()
13
14func receive_hit(hitbox: HitboxComponent) -> void:
15 hurt.emit(hitbox)
16
17 if health_component:
18 health_component.take_damage(hitbox.damage, hitbox.owner_node)

Pattern 6: Scene Management

 1# scene_manager.gd (Autoload)
 2extends Node
 3
 4signal scene_loading_started(scene_path: String)
 5signal scene_loading_progress(progress: float)
 6signal scene_loaded(scene: Node)
 7signal transition_started
 8signal transition_finished
 9
10@export var transition_scene: PackedScene
11@export var loading_scene: PackedScene
12
13var _current_scene: Node
14var _transition: CanvasLayer
15var _loader: ResourceLoader
16
17func _ready() -> void:
18 _current_scene = get_tree().current_scene
19
20 if transition_scene:
21 _transition = transition_scene.instantiate()
22 add_child(_transition)
23 _transition.visible = false
24
25func change_scene(scene_path: String, with_transition: bool = true) -> void:
26 if with_transition:
27 await _play_transition_out()
28
29 _load_scene(scene_path)
30
31func change_scene_packed(scene: PackedScene, with_transition: bool = true) -> void:
32 if with_transition:
33 await _play_transition_out()
34
35 _swap_scene(scene.instantiate())
36
37func _load_scene(path: String) -> void:
38 scene_loading_started.emit(path)
39
40 # Check if already loaded
41 if ResourceLoader.has_cached(path):
42 var scene := load(path) as PackedScene
43 _swap_scene(scene.instantiate())
44 return
45
46 # Async loading
47 ResourceLoader.load_threaded_request(path)
48
49 while true:
50 var progress := []
51 var status := ResourceLoader.load_threaded_get_status(path, progress)
52
53 match status:
54 ResourceLoader.THREAD_LOAD_IN_PROGRESS:
55 scene_loading_progress.emit(progress[0])
56 await get_tree().process_frame
57 ResourceLoader.THREAD_LOAD_LOADED:
58 var scene := ResourceLoader.load_threaded_get(path) as PackedScene
59 _swap_scene(scene.instantiate())
60 return
61 _:
62 push_error("Failed to load scene: %s" % path)
63 return
64
65func _swap_scene(new_scene: Node) -> void:
66 if _current_scene:
67 _current_scene.queue_free()
68
69 _current_scene = new_scene
70 get_tree().root.add_child(_current_scene)
71 get_tree().current_scene = _current_scene
72
73 scene_loaded.emit(_current_scene)
74 await _play_transition_in()
75
76func _play_transition_out() -> void:
77 if not _transition:
78 return
79
80 transition_started.emit()
81 _transition.visible = true
82
83 if _transition.has_method("transition_out"):
84 await _transition.transition_out()
85 else:
86 await get_tree().create_timer(0.3).timeout
87
88func _play_transition_in() -> void:
89 if not _transition:
90 transition_finished.emit()
91 return
92
93 if _transition.has_method("transition_in"):
94 await _transition.transition_in()
95 else:
96 await get_tree().create_timer(0.3).timeout
97
98 _transition.visible = false
99 transition_finished.emit()

Pattern 7: Save System

 1# save_manager.gd (Autoload)
 2extends Node
 3
 4const SAVE_PATH := "user://savegame.save"
 5const ENCRYPTION_KEY := "your_secret_key_here"
 6
 7signal save_completed
 8signal load_completed
 9signal save_error(message: String)
10
11func save_game(data: Dictionary) -> void:
12 var file := FileAccess.open_encrypted_with_pass(
13 SAVE_PATH,
14 FileAccess.WRITE,
15 ENCRYPTION_KEY
16 )
17
18 if file == null:
19 save_error.emit("Could not open save file")
20 return
21
22 var json := JSON.stringify(data)
23 file.store_string(json)
24 file.close()
25
26 save_completed.emit()
27
28func load_game() -> Dictionary:
29 if not FileAccess.file_exists(SAVE_PATH):
30 return {}
31
32 var file := FileAccess.open_encrypted_with_pass(
33 SAVE_PATH,
34 FileAccess.READ,
35 ENCRYPTION_KEY
36 )
37
38 if file == null:
39 save_error.emit("Could not open save file")
40 return {}
41
42 var json := file.get_as_text()
43 file.close()
44
45 var parsed := JSON.parse_string(json)
46 if parsed == null:
47 save_error.emit("Could not parse save data")
48 return {}
49
50 load_completed.emit()
51 return parsed
52
53func delete_save() -> void:
54 if FileAccess.file_exists(SAVE_PATH):
55 DirAccess.remove_absolute(SAVE_PATH)
56
57func has_save() -> bool:
58 return FileAccess.file_exists(SAVE_PATH)

 1# saveable.gd (Attach to saveable nodes)
 2class_name Saveable
 3extends Node
 4
 5@export var save_id: String
 6
 7func _ready() -> void:
 8 if save_id.is_empty():
 9 save_id = str(get_path())
10
11func get_save_data() -> Dictionary:
12 var parent := get_parent()
13 var data := {"id": save_id}
14
15 if parent is Node2D:
16 data["position"] = {"x": parent.position.x, "y": parent.position.y}
17
18 if parent.has_method("get_custom_save_data"):
19 data.merge(parent.get_custom_save_data())
20
21 return data
22
23func load_save_data(data: Dictionary) -> void:
24 var parent := get_parent()
25
26 if data.has("position") and parent is Node2D:
27 parent.position = Vector2(data.position.x, data.position.y)
28
29 if parent.has_method("load_custom_save_data"):
30 parent.load_custom_save_data(data)

Performance Tips

 1# 1. Cache node references
 2@onready var sprite := $Sprite2D # Good
 3# $Sprite2D in _process() # Bad - repeated lookup
 4
 5# 2. Use object pooling for frequent spawning
 6# See Pattern 4
 7
 8# 3. Avoid allocations in hot paths
 9var _reusable_array: Array = []
10
11func _process(_delta: float) -> void:
12 _reusable_array.clear() # Reuse instead of creating new
13
14# 4. Use static typing
15func calculate(value: float) -> float: # Good
16 return value * 2.0
17
18# 5. Disable processing when not needed
19func _on_off_screen() -> void:
20 set_process(false)
21 set_physics_process(false)

Best Practices

Do’s

Use signals for decoupling - Avoid direct references
Type everything - Static typing catches errors
Use resources for data - Separate data from logic
Pool frequently spawned objects - Avoid GC hitches
Use Autoloads sparingly - Only for truly global systems

Don’ts

Don’t use get_node() in loops - Cache references
Don’t couple scenes tightly - Use signals
Don’t put logic in resources - Keep them data-only
Don’t ignore the Profiler - Monitor performance
Don’t fight the scene tree - Work with Godot’s design

Resources

Gpui Action

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

Overview

Actions provide declarative keyboard-driven UI interactions in GPUI.

Key Concepts:

Define actions with actions! macro or #[derive(Action)]
Bind keys with cx.bind_keys()
Handle with .on_action() on elements
Context-aware via key_context()

Quick Start

Simple Actions

 1use gpui::actions;
 2
 3actions!(editor, [MoveUp, MoveDown, Save, Quit]);
 4
 5const CONTEXT: &str = "Editor";
 6
 7pub fn init(cx: &mut App) {
 8 cx.bind_keys([
 9 KeyBinding::new("up", MoveUp, Some(CONTEXT)),
10 KeyBinding::new("down", MoveDown, Some(CONTEXT)),
11 KeyBinding::new("cmd-s", Save, Some(CONTEXT)),
12 KeyBinding::new("cmd-q", Quit, Some(CONTEXT)),
13 ]);
14}
15
16impl Render for Editor {
17 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
18 div()
19 .key_context(CONTEXT)
20 .on_action(cx.listener(Self::move_up))
21 .on_action(cx.listener(Self::move_down))
22 .on_action(cx.listener(Self::save))
23 }
24}
25
26impl Editor {
27 fn move_up(&mut self, _: &MoveUp, cx: &mut Context<Self>) {
28 // Handle move up
29 cx.notify();
30 }
31
32 fn move_down(&mut self, _: &MoveDown, cx: &mut Context<Self>) {
33 cx.notify();
34 }
35
36 fn save(&mut self, _: &Save, cx: &mut Context<Self>) {
37 // Save logic
38 cx.notify();
39 }
40}

Actions with Parameters

 1#[derive(Clone, PartialEq, Action, Deserialize)]
 2#[action(namespace = editor)]
 3pub struct InsertText {
 4 pub text: String,
 5}
 6
 7#[derive(Action, Clone, PartialEq, Eq, Deserialize)]
 8#[action(namespace = editor, no_json)]
 9pub struct Digit(pub u8);
10
11cx.bind_keys([
12 KeyBinding::new("0", Digit(0), Some(CONTEXT)),
13 KeyBinding::new("1", Digit(1), Some(CONTEXT)),
14 // ...
15]);
16
17impl Editor {
18 fn on_digit(&mut self, action: &Digit, cx: &mut Context<Self>) {
19 self.insert_digit(action.0, cx);
20 }
21}

Key Formats

 1// Modifiers
 2"cmd-s" // Command (macOS) / Ctrl (Windows/Linux)
 3"ctrl-c" // Control
 4"alt-f" // Alt
 5"shift-tab" // Shift
 6"cmd-ctrl-f" // Multiple modifiers
 7
 8// Keys
 9"a-z", "0-9" // Letters and numbers
10"f1-f12" // Function keys
11"up", "down", "left", "right"
12"enter", "escape", "space", "tab"
13"backspace", "delete"
14"-", "=", "[", "]", etc. // Special characters

Action Naming

Prefer verb-noun pattern:

Gpui Async

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

Overview

GPUI provides integrated async runtime for foreground UI updates and background computation.

Key Concepts:

Foreground tasks: UI thread, can update entities (cx.spawn)
Background tasks: Worker threads, CPU-intensive work (cx.background_spawn)
All entity updates happen on foreground thread

Quick Start

Foreground Tasks (UI Updates)

 1impl MyComponent {
 2 fn fetch_data(&mut self, cx: &mut Context<Self>) {
 3 let entity = cx.entity().downgrade();
 4
 5 cx.spawn(async move |cx| {
 6 // Runs on UI thread, can await and update entities
 7 let data = fetch_from_api().await;
 8
 9 entity.update(cx, |state, cx| {
10 state.data = Some(data);
11 cx.notify();
12 }).ok();
13 }).detach();
14 }
15}

Background Tasks (Heavy Work)

 1impl MyComponent {
 2 fn process_file(&mut self, cx: &mut Context<Self>) {
 3 let entity = cx.entity().downgrade();
 4
 5 cx.background_spawn(async move {
 6 // Runs on background thread, CPU-intensive
 7 let result = heavy_computation().await;
 8 result
 9 })
10 .then(cx.spawn(move |result, cx| {
11 // Back to foreground to update UI
12 entity.update(cx, |state, cx| {
13 state.result = result;
14 cx.notify();
15 }).ok();
16 }))
17 .detach();
18 }
19}

Task Management

 1struct MyView {
 2 _task: Task<()>, // Prefix with _ if stored but not accessed
 3}
 4
 5impl MyView {
 6 fn new(cx: &mut Context<Self>) -> Self {
 7 let entity = cx.entity().downgrade();
 8
 9 let _task = cx.spawn(async move |cx| {
10 // Task automatically cancelled when dropped
11 loop {
12 tokio::time::sleep(Duration::from_secs(1)).await;
13 entity.update(cx, |state, cx| {
14 state.tick();
15 cx.notify();
16 }).ok();
17 }
18 });
19
20 Self { _task }
21 }
22}

Core Patterns

1. Async Data Fetching

1cx.spawn(async move |cx| {
2 let data = fetch_data().await?;
3 entity.update(cx, |state, cx| {
4 state.data = Some(data);
5 cx.notify();
6 })?;
7 Ok::<_, anyhow::Error>(())
8}).detach();

2. Background Computation + UI Update

 1cx.background_spawn(async move {
 2 heavy_work()
 3})
 4.then(cx.spawn(move |result, cx| {
 5 entity.update(cx, |state, cx| {
 6 state.result = result;
 7 cx.notify();
 8 }).ok();
 9}))
10.detach();

3. Periodic Tasks

1cx.spawn(async move |cx| {
2 loop {
3 tokio::time::sleep(Duration::from_secs(5)).await;
4 // Update every 5 seconds
5 }
6}).detach();

4. Task Cancellation

Tasks are automatically cancelled when dropped. Store in struct to keep alive.

Gpui Context

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

Overview

GPUI uses different context types for different scenarios:

Context Types:

App: Global app state, entity creation
Window: Window-specific operations, painting, layout
Context<T>: Entity-specific context for component T
AsyncApp: Async context for foreground tasks
AsyncWindowContext: Async context with window access

Quick Start

Context - Component Context

 1impl MyComponent {
 2 fn update_state(&mut self, cx: &mut Context<Self>) {
 3 self.value = 42;
 4 cx.notify(); // Trigger re-render
 5
 6 // Spawn async task
 7 cx.spawn(async move |cx| {
 8 // Async work
 9 }).detach();
10
11 // Get current entity
12 let entity = cx.entity();
13 }
14}

App - Global Context

 1fn main() {
 2 let app = Application::new();
 3 app.run(|cx: &mut App| {
 4 // Create entities
 5 let entity = cx.new(|cx| MyState::default());
 6
 7 // Open windows
 8 cx.open_window(WindowOptions::default(), |window, cx| {
 9 cx.new(|cx| Root::new(view, window, cx))
10 });
11 });
12}

Window - Window Context

1impl Render for MyView {
2 fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3 // Window operations
4 let is_focused = window.is_window_focused();
5 let bounds = window.bounds();
6
7 div().child("Content")
8 }
9}

AsyncApp - Async Context

1cx.spawn(async move |cx: &mut AsyncApp| {
2 let data = fetch_data().await;
3
4 entity.update(cx, |state, inner_cx| {
5 state.data = data;
6 inner_cx.notify();
7 }).ok();
8}).detach();

Common Operations

Entity Operations

 1// Create entity
 2let entity = cx.new(|cx| MyState::default());
 3
 4// Update entity
 5entity.update(cx, |state, cx| {
 6 state.value = 42;
 7 cx.notify();
 8});
 9
10// Read entity
11let value = entity.read(cx).value;

Notifications and Events

 1// Trigger re-render
 2cx.notify();
 3
 4// Emit event
 5cx.emit(MyEvent::Updated);
 6
 7// Observe entity
 8cx.observe(&entity, |this, observed, cx| {
 9 // React to changes
10}).detach();
11
12// Subscribe to events
13cx.subscribe(&entity, |this, source, event, cx| {
14 // Handle event
15}).detach();

Window Operations

1// Window state
2let focused = window.is_window_focused();
3let bounds = window.bounds();
4let scale = window.scale_factor();
5
6// Close window
7window.remove_window();

Async Operations

1// Spawn foreground task
2cx.spawn(async move |cx| {
3 // Async work with entity access
4}).detach();
5
6// Spawn background task
7cx.background_spawn(async move {
8 // Heavy computation
9}).detach();

Context Hierarchy

App (Global)
 └─ Window (Per-window)
 └─ Context<T> (Per-component)
 └─ AsyncApp (In async tasks)
 └─ AsyncWindowContext (Async + Window)

Reference Documentation

API Reference: See api-reference.md
- Complete context API, methods, conversions
- Entity operations, window operations
- Async contexts, best practices

Gpui Entity

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

Overview

An Entity<T> is a handle to state of type T, providing safe access and updates.

Key Methods:

entity.read(cx) → &T - Read-only access
entity.read_with(cx, |state, cx| ...) → R - Read with closure
entity.update(cx, |state, cx| ...) → R - Mutable update
entity.downgrade() → WeakEntity<T> - Create weak reference
entity.entity_id() → EntityId - Unique identifier

Entity Types:

Entity<T>: Strong reference (increases ref count)
WeakEntity<T>: Weak reference (doesn’t prevent cleanup, returns Result)

Quick Start

Creating and Using Entities

 1// Create entity
 2let counter = cx.new(|cx| Counter { count: 0 });
 3
 4// Read state
 5let count = counter.read(cx).count;
 6
 7// Update state
 8counter.update(cx, |state, cx| {
 9 state.count += 1;
10 cx.notify(); // Trigger re-render
11});
12
13// Weak reference (for closures/callbacks)
14let weak = counter.downgrade();
15let _ = weak.update(cx, |state, cx| {
16 state.count += 1;
17 cx.notify();
18});

In Components

 1struct MyComponent {
 2 shared_state: Entity<SharedData>,
 3}
 4
 5impl MyComponent {
 6 fn new(cx: &mut App) -> Entity<Self> {
 7 let shared = cx.new(|_| SharedData::default());
 8
 9 cx.new(|cx| Self {
10 shared_state: shared,
11 })
12 }
13
14 fn update_shared(&mut self, cx: &mut Context<Self>) {
15 self.shared_state.update(cx, |state, cx| {
16 state.value = 42;
17 cx.notify();
18 });
19 }
20}

Async Operations

 1impl MyComponent {
 2 fn fetch_data(&mut self, cx: &mut Context<Self>) {
 3 let weak_self = cx.entity().downgrade();
 4
 5 cx.spawn(async move |cx| {
 6 let data = fetch_from_api().await;
 7
 8 // Update entity safely
 9 let _ = weak_self.update(cx, |state, cx| {
10 state.data = Some(data);
11 cx.notify();
12 });
13 }).detach();
14 }
15}

Core Principles

Always Use Weak References in Closures

 1// ✅ Good: Weak reference prevents retain cycles
 2let weak = cx.entity().downgrade();
 3callback(move || {
 4 let _ = weak.update(cx, |state, cx| cx.notify());
 5});
 6
 7// ❌ Bad: Strong reference may cause memory leak
 8let strong = cx.entity();
 9callback(move || {
10 strong.update(cx, |state, cx| cx.notify());
11});

Use Inner Context

1// ✅ Good: Use inner cx from closure
2entity.update(cx, |state, inner_cx| {
3 inner_cx.notify(); // Correct
4});
5
6// ❌ Bad: Use outer cx (multiple borrow error)
7entity.update(cx, |state, inner_cx| {
8 cx.notify(); // Wrong!
9});

Avoid Nested Updates

1// ✅ Good: Sequential updates
2entity1.update(cx, |state, cx| { /* ... */ });
3entity2.update(cx, |state, cx| { /* ... */ });
4
5// ❌ Bad: Nested updates (may panic)
6entity1.update(cx, |_, cx| {
7 entity2.update(cx, |_, cx| { /* ... */ });
8});

Common Use Cases

Component State: Internal state that needs reactivity
Shared State: State shared between multiple components
Parent-Child: Coordinating between related components (use weak refs)
Async State: Managing state that changes from async operations
Observations: Reacting to changes in other entities

Reference Documentation

Complete API Documentation

Entity API: See api-reference.md
- Entity types, methods, lifecycle
- Context methods, async operations
- Error handling, type conversions

Implementation Guides

Patterns: See patterns.md

Gpui Focus Handle

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

Overview

GPUI’s focus system enables keyboard navigation and focus management.

Key Concepts:

FocusHandle: Reference to focusable element
Focus tracking: Current focused element
Keyboard navigation: Tab/Shift-Tab between elements
Focus events: on_focus, on_blur

Quick Start

Creating Focus Handles

 1struct FocusableComponent {
 2 focus_handle: FocusHandle,
 3}
 4
 5impl FocusableComponent {
 6 fn new(cx: &mut Context<Self>) -> Self {
 7 Self {
 8 focus_handle: cx.focus_handle(),
 9 }
10 }
11}

Making Elements Focusable

 1impl Render for FocusableComponent {
 2 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
 3 div()
 4 .track_focus(&self.focus_handle)
 5 .on_action(cx.listener(Self::on_enter))
 6 .child("Focusable content")
 7 }
 8
 9 fn on_enter(&mut self, _: &Enter, cx: &mut Context<Self>) {
10 // Handle Enter key when focused
11 cx.notify();
12 }
13}

Focus Management

 1impl MyComponent {
 2 fn focus(&mut self, cx: &mut Context<Self>) {
 3 self.focus_handle.focus(cx);
 4 }
 5
 6 fn is_focused(&self, cx: &App) -> bool {
 7 self.focus_handle.is_focused(cx)
 8 }
 9
10 fn blur(&mut self, cx: &mut Context<Self>) {
11 cx.blur();
12 }
13}

Focus Events

Handling Focus Changes

 1impl Render for MyInput {
 2 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
 3 let is_focused = self.focus_handle.is_focused(cx);
 4
 5 div()
 6 .track_focus(&self.focus_handle)
 7 .on_focus(cx.listener(|this, _event, cx| {
 8 this.on_focus(cx);
 9 }))
10 .on_blur(cx.listener(|this, _event, cx| {
11 this.on_blur(cx);
12 }))
13 .when(is_focused, |el| {
14 el.bg(cx.theme().focused_background)
15 })
16 .child(self.render_content())
17 }
18}
19
20impl MyInput {
21 fn on_focus(&mut self, cx: &mut Context<Self>) {
22 // Handle focus gained
23 cx.notify();
24 }
25
26 fn on_blur(&mut self, cx: &mut Context<Self>) {
27 // Handle focus lost
28 cx.notify();
29 }
30}

Tab Order

Elements with track_focus() automatically participate in Tab navigation.

Gpui Global

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

Overview

Global state in GPUI provides app-wide shared data accessible from any context.

Key Trait: Global - Implement on types to make them globally accessible

Quick Start

Define Global State

1use gpui::Global;
2
3#[derive(Clone)]
4struct AppSettings {
5 theme: Theme,
6 language: String,
7}
8
9impl Global for AppSettings {}

Set and Access Globals

 1fn main() {
 2 let app = Application::new();
 3 app.run(|cx: &mut App| {
 4 // Set global
 5 cx.set_global(AppSettings {
 6 theme: Theme::Dark,
 7 language: "en".to_string(),
 8 });
 9
10 // Access global (read-only)
11 let settings = cx.global::<AppSettings>();
12 println!("Theme: {:?}", settings.theme);
13 });
14}

Update Globals

 1impl MyComponent {
 2 fn change_theme(&mut self, new_theme: Theme, cx: &mut Context<Self>) {
 3 cx.update_global::<AppSettings, _>(|settings, cx| {
 4 settings.theme = new_theme;
 5 // Global updates don't trigger automatic notifications
 6 // Manually notify components that care
 7 });
 8
 9 cx.notify(); // Re-render this component
10 }
11}

Common Use Cases

1. App Configuration

 1#[derive(Clone)]
 2struct AppConfig {
 3 api_endpoint: String,
 4 max_retries: u32,
 5 timeout: Duration,
 6}
 7
 8impl Global for AppConfig {}
 9
10// Set once at startup
11cx.set_global(AppConfig {
12 api_endpoint: "https://api.example.com".to_string(),
13 max_retries: 3,
14 timeout: Duration::from_secs(30),
15});
16
17// Access anywhere
18let config = cx.global::<AppConfig>();

2. Feature Flags

 1#[derive(Clone)]
 2struct FeatureFlags {
 3 enable_beta_features: bool,
 4 enable_analytics: bool,
 5}
 6
 7impl Global for FeatureFlags {}
 8
 9impl MyComponent {
10 fn render_beta_feature(&self, cx: &App) -> Option<impl IntoElement> {
11 let flags = cx.global::<FeatureFlags>();
12
13 if flags.enable_beta_features {
14 Some(div().child("Beta feature"))
15 } else {
16 None
17 }
18 }
19}

3. Shared Services

 1#[derive(Clone)]
 2struct ServiceRegistry {
 3 http_client: Arc<HttpClient>,
 4 logger: Arc<Logger>,
 5}
 6
 7impl Global for ServiceRegistry {}
 8
 9impl MyComponent {
10 fn fetch_data(&mut self, cx: &mut Context<Self>) {
11 let registry = cx.global::<ServiceRegistry>();
12 let client = registry.http_client.clone();
13
14 cx.spawn(async move |cx| {
15 let data = client.get("api/data").await?;
16 // Process data...
17 Ok::<_, anyhow::Error>(())
18 }).detach();
19 }
20}

Best Practices

✅ Use Arc for Shared Resources

1#[derive(Clone)]
2struct GlobalState {
3 database: Arc<Database>, // Cheap to clone
4 cache: Arc<RwLock<Cache>>,
5}
6
7impl Global for GlobalState {}

✅ Immutable by Default

Globals are read-only by default. Use interior mutability when needed:

Gpui Layout And Style

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

Overview

GPUI provides CSS-like styling with Rust type safety.

Key Concepts:

Flexbox layout system
Styled trait for chaining styles
Size units: px(), rems(), relative()
Colors, borders, shadows

Quick Start

Basic Styling

 1use gpui::*;
 2
 3div()
 4 .w(px(200.))
 5 .h(px(100.))
 6 .bg(rgb(0x2196F3))
 7 .text_color(rgb(0xFFFFFF))
 8 .rounded(px(8.))
 9 .p(px(16.))
10 .child("Styled content")

Flexbox Layout

 1div()
 2 .flex()
 3 .flex_row() // or flex_col() for column
 4 .gap(px(8.))
 5 .items_center()
 6 .justify_between()
 7 .children([
 8 div().child("Item 1"),
 9 div().child("Item 2"),
10 div().child("Item 3"),
11 ])

Size Units

1div()
2 .w(px(200.)) // Pixels
3 .h(rems(10.)) // Relative to font size
4 .w(relative(0.5)) // 50% of parent
5 .min_w(px(100.))
6 .max_w(px(400.))

Common Patterns

Centered Content

1div()
2 .flex()
3 .items_center()
4 .justify_center()
5 .size_full()
6 .child("Centered")

Card Layout

 1div()
 2 .w(px(300.))
 3 .bg(cx.theme().surface)
 4 .rounded(px(8.))
 5 .shadow_md()
 6 .p(px(16.))
 7 .gap(px(12.))
 8 .flex()
 9 .flex_col()
10 .child(heading())
11 .child(content())

Responsive Spacing

1div()
2 .p(px(16.)) // Padding all sides
3 .px(px(20.)) // Padding horizontal
4 .py(px(12.)) // Padding vertical
5 .pt(px(8.)) // Padding top
6 .gap(px(8.)) // Gap between children

Styling Methods

Dimensions

1.w(px(200.)) // Width
2.h(px(100.)) // Height
3.size(px(200.)) // Width and height
4.min_w(px(100.)) // Min width
5.max_w(px(400.)) // Max width

Colors

1.bg(rgb(0x2196F3)) // Background
2.text_color(rgb(0xFFFFFF)) // Text color
3.border_color(rgb(0x000000)) // Border color

Borders

1.border(px(1.)) // Border width
2.rounded(px(8.)) // Border radius
3.rounded_t(px(8.)) // Top corners
4.border_color(rgb(0x000000))

Spacing

1.p(px(16.)) // Padding
2.m(px(8.)) // Margin
3.gap(px(8.)) // Gap between flex children

Flexbox

1.flex() // Enable flexbox
2.flex_row() // Row direction
3.flex_col() // Column direction
4.items_center() // Align items center
5.justify_between() // Space between items
6.flex_grow() // Grow to fill space

Theme Integration

1div()
2 .bg(cx.theme().surface)
3 .text_color(cx.theme().foreground)
4 .border_color(cx.theme().border)
5 .when(is_hovered, |el| {
6 el.bg(cx.theme().hover)
7 })

Conditional Styling

1div()
2 .when(is_active, |el| {
3 el.bg(cx.theme().primary)
4 })
5 .when_some(optional_color, |el, color| {
6 el.bg(color)
7 })

Reference Documentation

Complete Guide: See reference.md
- All styling methods
- Layout strategies
- Theming, responsive design

Grafana Dashboards

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

Grafana Dashboards

Create and manage production-ready Grafana dashboards for comprehensive system observability.

Purpose

Design effective Grafana dashboards for monitoring applications, infrastructure, and business metrics.

When to Use

Visualize Prometheus metrics
Create custom dashboards
Implement SLO dashboards
Monitor infrastructure
Track business KPIs

Dashboard Design Principles

1. Hierarchy of Information

┌─────────────────────────────────────┐
│ Critical Metrics (Big Numbers) │
├─────────────────────────────────────┤
│ Key Trends (Time Series) │
├─────────────────────────────────────┤
│ Detailed Metrics (Tables/Heatmaps) │
└─────────────────────────────────────┘

2. RED Method (Services)

Rate - Requests per second
Errors - Error rate
Duration - Latency/response time

3. USE Method (Resources)

Utilization - % time resource is busy
Saturation - Queue length/wait time
Errors - Error count

Dashboard Structure

API Monitoring Dashboard

 1{
 2 "dashboard": {
 3 "title": "API Monitoring",
 4 "tags": ["api", "production"],
 5 "timezone": "browser",
 6 "refresh": "30s",
 7 "panels": [
 8 {
 9 "title": "Request Rate",
10 "type": "graph",
11 "targets": [
12 {
13 "expr": "sum(rate(http_requests_total[5m])) by (service)",
14 "legendFormat": "{{service}}"
15 }
16 ],
17 "gridPos": { "x": 0, "y": 0, "w": 12, "h": 8 }
18 },
19 {
20 "title": "Error Rate %",
21 "type": "graph",
22 "targets": [
23 {
24 "expr": "(sum(rate(http_requests_total{status=~\"5..\"}[5m])) / sum(rate(http_requests_total[5m]))) * 100",
25 "legendFormat": "Error Rate"
26 }
27 ],
28 "alert": {
29 "conditions": [
30 {
31 "evaluator": { "params": [5], "type": "gt" },
32 "operator": { "type": "and" },
33 "query": { "params": ["A", "5m", "now"] },
34 "type": "query"
35 }
36 ]
37 },
38 "gridPos": { "x": 12, "y": 0, "w": 12, "h": 8 }
39 },
40 {
41 "title": "P95 Latency",
42 "type": "graph",
43 "targets": [
44 {
45 "expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service))",
46 "legendFormat": "{{service}}"
47 }
48 ],
49 "gridPos": { "x": 0, "y": 8, "w": 24, "h": 8 }
50 }
51 ]
52 }
53}

Reference: See assets/api-dashboard.json

Guidance

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

Guidance: Constrained LLM Generation

When to Use This Skill

Use Guidance when you need to:

Control LLM output syntax with regex or grammars
Guarantee valid JSON/XML/code generation
Reduce latency vs traditional prompting approaches
Enforce structured formats (dates, emails, IDs, etc.)
Build multi-step workflows with Pythonic control flow
Prevent invalid outputs through grammatical constraints

GitHub Stars: 18,000+ | From: Microsoft Research

Installation

1# Base installation
2pip install guidance
3
4# With specific backends
5pip install guidance[transformers] # Hugging Face models
6pip install guidance[llama_cpp] # llama.cpp models

Quick Start

Basic Example: Structured Generation

1from guidance import models, gen
2
3# Load model (supports OpenAI, Transformers, llama.cpp)
4lm = models.OpenAI("gpt-4")
5
6# Generate with constraints
7result = lm + "The capital of France is " + gen("capital", max_tokens=5)
8
9print(result["capital"]) # "Paris"

With Anthropic Claude

 1from guidance import models, gen, system, user, assistant
 2
 3# Configure Claude
 4lm = models.Anthropic("claude-sonnet-4-5-20250929")
 5
 6# Use context managers for chat format
 7with system():
 8 lm += "You are a helpful assistant."
 9
10with user():
11 lm += "What is the capital of France?"
12
13with assistant():
14 lm += gen(max_tokens=20)

Core Concepts

1. Context Managers

Guidance uses Pythonic context managers for chat-style interactions.

Hook Development

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

Hook Development for Claude Code Plugins

Overview

Hooks are event-driven automation scripts that execute in response to Claude Code events. Use hooks to validate operations, enforce policies, add context, and integrate external tools into workflows.

Key capabilities:

Validate tool calls before execution (PreToolUse)
React to tool results (PostToolUse)
Enforce completion standards (Stop, SubagentStop)
Load project context (SessionStart)
Automate workflows across the development lifecycle

Hook Types

Prompt-Based Hooks (Recommended)

Use LLM-driven decision making for context-aware validation:

Hooks Automation

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

Hooks Automation

Intelligent automation system that coordinates, validates, and learns from Claude Code operations through hooks integrated with MCP tools and neural pattern training.

What This Skill Does

This skill provides a comprehensive hook system that automatically manages development operations, coordinates swarm agents, maintains session state, and continuously learns from coding patterns. It enables automated agent assignment, code formatting, performance tracking, and cross-session memory persistence.

Key Capabilities:

Pre-Operation Hooks: Validate, prepare, and auto-assign agents before operations
Post-Operation Hooks: Format, analyze, and train patterns after operations
Session Management: Persist state, restore context, generate summaries
Memory Coordination: Synchronize knowledge across swarm agents
Git Integration: Automated commit hooks with quality verification
Neural Training: Continuous learning from successful patterns
MCP Integration: Seamless coordination with swarm tools

Prerequisites

Required:

Hosted Agents

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

Hosted Agent Infrastructure

Hosted agents run in remote sandboxed environments rather than on local machines. When designed well, they provide unlimited concurrency, consistent execution environments, and multiplayer collaboration. The critical insight is that session speed should be limited only by model provider time-to-first-token, with all infrastructure setup completed before the user starts their session.

When to Activate

Activate this skill when:

Building background coding agents that run independently of user devices
Designing sandboxed execution environments for agent workloads
Implementing multiplayer agent sessions with shared state
Creating multi-client agent interfaces (Slack, Web, Chrome extensions)
Scaling agent infrastructure beyond local machine constraints
Building systems where agents spawn sub-agents for parallel work

Core Concepts

Hosted agents address the fundamental limitation of local agent execution: resource contention, environment inconsistency, and single-user constraints. By moving agent execution to remote sandboxed environments, teams gain unlimited concurrency, reproducible environments, and collaborative workflows.

Hula Skill

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

HuLa Skill

Overview

Enable consistent changes across the HuLa frontend, backend, full-stack flows, and build/release tasks with repo-specific conventions and resources.

Activation Gate

Ask which scope to enable: frontend, backend, fullstack, or build-release. Confirm platform (desktop or mobile), target area (view/component/store/command), and any constraints before editing.

Workflow

Identify scope and platform.
Locate similar code paths and follow existing patterns.
Apply changes using repo conventions and available templates.
Update related layers (routes, stores, commands) when needed.
Propose or run checks/tests only when requested.

Scope Routing

Frontend: read references/frontend.md and references/overview.md; use assets/templates/view-desktop.vue, assets/templates/view-mobile.vue, assets/templates/pinia-store.ts as starters.
Backend: read references/backend.md and references/overview.md; use assets/templates/tauri-command.rs.
Fullstack: read references/fullstack.md plus frontend/backend references; use assets/templates/tauri-command.ts.
Build/Release: read references/build-release.md and references/checklists.md.

Scripts

Use scripts/hula_summary.py for quick repo context (views/stores counts and paths). Use scripts/hula_tauri_map.py to list Tauri commands and frontend invoke usage.

Incident Runbook Templates

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

Incident Runbook Templates

Production-ready templates for incident response runbooks covering detection, triage, mitigation, resolution, and communication.

When to Use This Skill

Creating incident response procedures
Building service-specific runbooks
Establishing escalation paths
Documenting recovery procedures
Responding to active incidents
Onboarding on-call engineers

Core Concepts

1. Incident Severity Levels

Severity	Impact	Response Time	Example
SEV1	Complete outage, data loss	15 min	Production down
SEV2	Major degradation	30 min	Critical feature broken
SEV3	Minor impact	2 hours	Non-critical bug
SEV4	Minimal impact	Next business day	Cosmetic issue

2. Runbook Structure

1. Overview & Impact
2. Detection & Alerts
3. Initial Triage
4. Mitigation Steps
5. Root Cause Investigation
6. Resolution Procedures
7. Verification & Rollback
8. Communication Templates
9. Escalation Matrix

Runbook Templates

Template 1: Service Outage Runbook

 1# [Service Name] Outage Runbook
 2
 3## Overview
 4
 5**Service**: Payment Processing Service
 6**Owner**: Platform Team
 7**Slack**: #payments-incidents
 8**PagerDuty**: payments-oncall
 9
10## Impact Assessment
11
12- [ ] Which customers are affected?
13- [ ] What percentage of traffic is impacted?
14- [ ] Are there financial implications?
15- [ ] What's the blast radius?
16
17## Detection
18
19### Alerts
20
21- `payment_error_rate > 5%` (PagerDuty)
22- `payment_latency_p99 > 2s` (Slack)
23- `payment_success_rate < 95%` (PagerDuty)
24
25### Dashboards
26
27- [Payment Service Dashboard](https://grafana/d/payments)
28- [Error Tracking](https://sentry.io/payments)
29- [Dependency Status](https://status.stripe.com)
30
31## Initial Triage (First 5 Minutes)
32
33### 1. Assess Scope
34
35```bash
36# Check service health
37kubectl get pods -n payments -l app=payment-service
38
39# Check recent deployments
40kubectl rollout history deployment/payment-service -n payments
41
42# Check error rates
43curl -s "http://prometheus:9090/api/v1/query?query=sum(rate(http_requests_total{status=~'5..'}[5m]))"
44```

2. Quick Health Checks

Can you reach the service? curl -I https://api.company.com/payments/health
Database connectivity? Check connection pool metrics
External dependencies? Check Stripe, bank API status
Recent changes? Check deploy history

3. Initial Classification

Symptom	Likely Cause	Go To Section
All requests failing	Service down	Section 4.1
High latency	Database/dependency	Section 4.2
Partial failures	Code bug	Section 4.3
Spike in errors	Traffic surge	Section 4.4

Mitigation Procedures

4.1 Service Completely Down

 1# Step 1: Check pod status
 2kubectl get pods -n payments
 3
 4# Step 2: If pods are crash-looping, check logs
 5kubectl logs -n payments -l app=payment-service --tail=100
 6
 7# Step 3: Check recent deployments
 8kubectl rollout history deployment/payment-service -n payments
 9
10# Step 4: ROLLBACK if recent deploy is suspect
11kubectl rollout undo deployment/payment-service -n payments
12
13# Step 5: Scale up if resource constrained
14kubectl scale deployment/payment-service -n payments --replicas=10
15
16# Step 6: Verify recovery
17kubectl rollout status deployment/payment-service -n payments

4.2 High Latency

 1# Step 1: Check database connections
 2kubectl exec -n payments deploy/payment-service -- \
 3 curl localhost:8080/metrics | grep db_pool
 4
 5# Step 2: Check slow queries (if DB issue)
 6psql -h $DB_HOST -U $DB_USER -c "
 7 SELECT pid, now() - query_start AS duration, query
 8 FROM pg_stat_activity
 9 WHERE state = 'active' AND duration > interval '5 seconds'
10 ORDER BY duration DESC;"
11
12# Step 3: Kill long-running queries if needed
13psql -h $DB_HOST -U $DB_USER -c "SELECT pg_terminate_backend(pid);"
14
15# Step 4: Check external dependency latency
16curl -w "@curl-format.txt" -o /dev/null -s https://api.stripe.com/v1/health
17
18# Step 5: Enable circuit breaker if dependency is slow
19kubectl set env deployment/payment-service \
20 STRIPE_CIRCUIT_BREAKER_ENABLED=true -n payments

4.3 Partial Failures (Specific Errors)

 1# Step 1: Identify error pattern
 2kubectl logs -n payments -l app=payment-service --tail=500 | \
 3 grep -i error | sort | uniq -c | sort -rn | head -20
 4
 5# Step 2: Check error tracking
 6# Go to Sentry: https://sentry.io/payments
 7
 8# Step 3: If specific endpoint, enable feature flag to disable
 9curl -X POST https://api.company.com/internal/feature-flags \
10 -d '{"flag": "DISABLE_PROBLEMATIC_FEATURE", "enabled": true}'
11
12# Step 4: If data issue, check recent data changes
13psql -h $DB_HOST -c "
14 SELECT * FROM audit_log
15 WHERE table_name = 'payment_methods'
16 AND created_at > now() - interval '1 hour';"

4.4 Traffic Surge

 1# Step 1: Check current request rate
 2kubectl top pods -n payments
 3
 4# Step 2: Scale horizontally
 5kubectl scale deployment/payment-service -n payments --replicas=20
 6
 7# Step 3: Enable rate limiting
 8kubectl set env deployment/payment-service \
 9 RATE_LIMIT_ENABLED=true \
10 RATE_LIMIT_RPS=1000 -n payments
11
12# Step 4: If attack, block suspicious IPs
13kubectl apply -f - <<EOF
14apiVersion: networking.k8s.io/v1
15kind: NetworkPolicy
16metadata:
17 name: block-suspicious
18 namespace: payments
19spec:
20 podSelector:
21 matchLabels:
22 app: payment-service
23 ingress:
24 - from:
25 - ipBlock:
26 cidr: 0.0.0.0/0
27 except:
28 - 192.168.1.0/24 # Suspicious range
29EOF

Verification Steps

 1# Verify service is healthy
 2curl -s https://api.company.com/payments/health | jq
 3
 4# Verify error rate is back to normal
 5curl -s "http://prometheus:9090/api/v1/query?query=sum(rate(http_requests_total{status=~'5..'}[5m]))" | jq '.data.result[0].value[1]'
 6
 7# Verify latency is acceptable
 8curl -s "http://prometheus:9090/api/v1/query?query=histogram_quantile(0.99,sum(rate(http_request_duration_seconds_bucket[5m]))by(le))" | jq
 9
10# Smoke test critical flows
11./scripts/smoke-test-payments.sh

Rollback Procedures

1# Rollback Kubernetes deployment
2kubectl rollout undo deployment/payment-service -n payments
3
4# Rollback database migration (if applicable)
5./scripts/db-rollback.sh $MIGRATION_VERSION
6
7# Rollback feature flag
8curl -X POST https://api.company.com/internal/feature-flags \
9 -d '{"flag": "NEW_PAYMENT_FLOW", "enabled": false}'

Escalation Matrix

Condition	Escalate To	Contact
> 15 min unresolved SEV1	工程经理	@manager (Slack)
Data breach suspected	Security Team	#security-incidents
Financial impact > $10k	Finance + Legal	@finance-oncall
Customer communication needed	Support Lead	@support-lead

Communication Templates

Initial Notification (Internal)

🚨 INCIDENT: Payment Service Degradation

Severity: SEV2
Status: Investigating
Impact: ~20% of payment requests failing
Start Time: [TIME]
Incident Commander: [NAME]

Current Actions:
- Investigating root cause
- Scaling up service
- Monitoring dashboards

Updates in #payments-incidents

Status Update

📊 UPDATE: Payment Service Incident

Status: Mitigating
Impact: Reduced to ~5% failure rate
Duration: 25 minutes

Actions Taken:
- Rolled back deployment v2.3.4 → v2.3.3
- Scaled service from 5 → 10 replicas

Next Steps:
- Continuing to monitor
- Root cause analysis in progress

ETA to Resolution: ~15 minutes

Resolution Notification

✅ RESOLVED: Payment Service Incident

Duration: 45 minutes
Impact: ~5,000 affected transactions
Root Cause: Memory leak in v2.3.4

Resolution:
- Rolled back to v2.3.3
- Transactions auto-retried successfully

Follow-up:
- Postmortem scheduled for [DATE]
- Bug fix in progress


### Template 2: Database Incident Runbook

```markdown
# Database Incident Runbook

## Quick Reference
| Issue | Command |
|-------|---------|
| Check connections | `SELECT count(*) FROM pg_stat_activity;` |
| Kill query | `SELECT pg_terminate_backend(pid);` |
| Check replication lag | `SELECT extract(epoch from (now() - pg_last_xact_replay_timestamp()));` |
| Check locks | `SELECT * FROM pg_locks WHERE NOT granted;` |

## Connection Pool Exhaustion
```sql
-- Check current connections
SELECT datname, usename, state, count(*)
FROM pg_stat_activity
GROUP BY datname, usename, state
ORDER BY count(*) DESC;

-- Identify long-running connections
SELECT pid, usename, datname, state, query_start, query
FROM pg_stat_activity
WHERE state != 'idle'
ORDER BY query_start;

-- Terminate idle connections
SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE state = 'idle'
AND query_start < now() - interval '10 minutes';

Replication Lag

 1-- Check lag on replica
 2SELECT
 3 CASE
 4 WHEN pg_last_wal_receive_lsn() = pg_last_wal_replay_lsn() THEN 0
 5 ELSE extract(epoch from now() - pg_last_xact_replay_timestamp())
 6 END AS lag_seconds;
 7
 8-- If lag > 60s, consider:
 9-- 1. Check network between primary/replica
10-- 2. Check replica disk I/O
11-- 3. Consider failover if unrecoverable

Disk Space Critical

 1# Check disk usage
 2df -h /var/lib/postgresql/data
 3
 4# Find large tables
 5psql -c "SELECT relname, pg_size_pretty(pg_total_relation_size(relid))
 6FROM pg_catalog.pg_statio_user_tables
 7ORDER BY pg_total_relation_size(relid) DESC
 8LIMIT 10;"
 9
10# VACUUM to reclaim space
11psql -c "VACUUM FULL large_table;"
12
13# If emergency, delete old data or expand disk


## Best Practices

### Do's
- **Keep runbooks updated** - Review after every incident
- **Test runbooks regularly** - Game days, chaos engineering
- **Include rollback steps** - Always have an escape hatch
- **Document assumptions** - What must be true for steps to work
- **Link to dashboards** - Quick access during stress

### Don'ts
- **Don't assume knowledge** - Write for 3 AM brain
- **Don't skip verification** - Confirm each step worked
- **Don't forget communication** - Keep stakeholders informed
- **Don't work alone** - Escalate early
- **Don't skip postmortems** - Learn from every incident

## Resources

- [Google SRE Book - Incident Management](https://sre.google/sre-book/managing-incidents/)
- [PagerDuty Incident Response](https://response.pagerduty.com/)
- [Atlassian Incident Management](https://www.atlassian.com/incident-management)

Internal Comms

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

When to use this skill

To write internal communications, use this skill for:

3P updates (Progress, Plans, Problems)
Company newsletters
FAQ responses
Status reports
Leadership updates
Project updates
Incident reports

How to use this skill

To write any internal communication:

Identify the communication type from the request
Load the appropriate guideline file from the examples/ directory:
- examples/3p-updates.md - For Progress/Plans/Problems team updates
- examples/company-newsletter.md - For company-wide newsletters
- examples/faq-answers.md - For answering frequently asked questions
- examples/general-comms.md - For anything else that doesn’t explicitly match one of the above
Follow the specific instructions in that file for formatting, tone, and content gathering

If the communication type doesn’t match any existing guideline, ask for clarification or more context about the desired format.

Invoice Organizer

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

Invoice Organizer

This skill transforms chaotic folders of invoices, receipts, and financial documents into a clean, tax-ready filing system without manual effort.

When to Use This Skill

Preparing for tax season and need organized records
Managing business expenses across multiple vendors
Organizing receipts from a messy folder or email downloads
Setting up automated invoice filing for ongoing bookkeeping
Archiving financial records by year or category
Reconciling expenses for reimbursement
Preparing documentation for accountants

What This Skill Does

Reads Invoice Content: Extracts information from PDFs, images, and documents:

Issue Triage

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

Issue Triage Skill

This skill helps triage open GitHub issues in the dotnet/maui repository by:

Initializing a session with current milestones and labels
Loading a batch of issues into memory
Presenting issues ONE AT A TIME for triage decisions
Suggesting milestones based on issue characteristics
Tracking progress through a triage session

Prerequisites

GitHub CLI (gh) must be installed and authenticated:

 1# Install
 2# Windows:
 3winget install --id GitHub.cli
 4
 5# macOS:
 6brew install gh
 7
 8# Linux:
 9# See https://cli.github.com/manual/installation
10
11# Authenticate (required before first use)
12gh auth login

The scripts will check for gh and exit with installation instructions if not found.

Json Canvas

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

JSON Canvas Skill

This skill enables skills-compatible agents to create and edit valid JSON Canvas files (.canvas) used in Obsidian and other applications.

Overview

JSON Canvas is an open file format for infinite canvas data. Canvas files use the .canvas extension and contain valid JSON following the JSON Canvas Spec 1.0.

File Structure

A canvas file contains two top-level arrays:

1{
2 "nodes": [],
3 "edges": []
4}

nodes (optional): Array of node objects
edges (optional): Array of edge objects connecting nodes

Nodes

Nodes are objects placed on the canvas. There are four node types:

Labarchive Integration

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

LabArchives Integration

Overview

LabArchives is an electronic lab notebook platform for research documentation and data management. Access notebooks, manage entries and attachments, generate reports, and integrate with third-party tools programmatically via REST API.

When to Use This Skill

This skill should be used when:

Working with LabArchives REST API for notebook automation
Backing up notebooks programmatically
Creating or managing notebook entries and attachments
Generating site reports and analytics
Integrating LabArchives with third-party tools (Protocols.io, Jupyter, REDCap)
Automating data upload to electronic lab notebooks
Managing user access and permissions programmatically

Core Capabilities

1. Authentication and Configuration

Set up API access credentials and regional endpoints for LabArchives API integration.

Langsmith Observability

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

LangSmith - LLM Observability Platform

Development platform for debugging, evaluating, and monitoring language models and AI applications.

When to use LangSmith

Use LangSmith when:

Debugging LLM application issues (prompts, chains, agents)
Evaluating model outputs systematically against datasets
Monitoring production LLM systems
Building regression testing for AI features
Analyzing latency, token usage, and costs
Collaborating on prompt engineering

Key features:

Tracing: Capture inputs, outputs, latency for all LLM calls
Evaluation: Systematic testing with built-in and custom evaluators
Datasets: Create test sets from production traces or manually
Monitoring: Track metrics, errors, and costs in production
Integrations: Works with OpenAI, Anthropic, LangChain, LlamaIndex

Use alternatives instead:

Latchbio Integration

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

LatchBio Integration

Overview

Latch is a Python framework for building and deploying bioinformatics workflows as serverless pipelines. Built on Flyte, create workflows with @workflow/@task decorators, manage cloud data with LatchFile/LatchDir, configure resources, and integrate Nextflow/Snakemake pipelines.

Core Capabilities

The Latch platform provides four main areas of functionality:

1. Workflow Creation and Deployment

Define serverless workflows using Python decorators
Support for native Python, Nextflow, and Snakemake pipelines
Automatic containerization with Docker
Auto-generated no-code user interfaces
Version control and reproducibility

2. Data Management

Cloud storage abstractions (LatchFile, LatchDir)
Structured data organization with Registry (Projects → Tables → Records)
Type-safe data operations with links and enums
Automatic file transfer between local and cloud
Glob pattern matching for file selection

3. Resource Configuration

Pre-configured task decorators (@small_task, @large_task, @small_gpu_task, @large_gpu_task)
Custom resource specifications (CPU, memory, GPU, storage)
GPU support (K80, V100, A100)
Timeout and storage configuration
Cost optimization strategies

4. Verified Workflows

Production-ready pre-built pipelines
Bulk RNA-seq, DESeq2, pathway analysis
AlphaFold and ColabFold for protein structure prediction
Single-cell tools (ArchR, scVelo, emptyDropsR)
CRISPR analysis, phylogenetics, and more

Quick Start

Installation and Setup

 1# Install Latch SDK
 2python3 -m uv pip install latch
 3
 4# Login to Latch
 5latch login
 6
 7# Initialize a new workflow
 8latch init my-workflow
 9
10# Register workflow to platform
11latch register my-workflow

Prerequisites:

Lead Research Assistant

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

Lead Research Assistant

This skill helps you identify and qualify potential leads for your business by analyzing your product/service, understanding your ideal customer profile, and providing actionable outreach strategies.

When to Use This Skill

Finding potential customers or clients for your product/service
Building a list of companies to reach out to for partnerships
Identifying target accounts for sales outreach
Researching companies that match your ideal customer profile
Preparing for business development activities

What This Skill Does

Understands Your Business: Analyzes your product/service, value proposition, and target market
Identifies Target Companies: Finds companies that match your ideal customer profile based on:
- Industry and sector
- Company size and location
- Technology stack and tools they use
- Growth stage and funding
- Pain points your product solves
Prioritizes Leads: Ranks companies based on fit score and relevance
Provides Contact Strategies: Suggests how to approach each lead with personalized messaging
Enriches Data: Gathers relevant information about decision-makers and company context

How to Use

Basic Usage

Simply describe your product/service and what you’re looking for:

Linear

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

Linear

Overview

This skill provides a structured workflow for managing issues, projects & team workflows in Linear. It ensures consistent integration with the Linear MCP server, which offers natural-language project management for issues, projects, documentation, and team collaboration.

Prerequisites

Linear MCP server must be connected and accessible via OAuth
Confirm access to the relevant Linear workspace, teams, and projects

Required Workflow

Follow these steps in order. Do not skip steps.

Marketing Demand Acquisition

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

Marketing Demand & Acquisition

Expert acquisition playbook for Series A+ startups scaling internationally (EU/US/Canada) with hybrid PLG/Sales-Led motion.

Keywords

demand generation, paid media, paid ads, LinkedIn ads, Google ads, Meta ads, CAC, customer acquisition cost, lead generation, MQL, SQL, pipeline generation, acquisition strategy, performance marketing, paid social, paid search, partnerships, affiliate marketing, SEO strategy, HubSpot campaigns, marketing automation, B2B marketing, SaaS marketing

Role Coverage

This skill serves:

Demand Generation Manager - Multi-channel campaigns, pipeline generation
Paid Media/Performance Marketer - Paid search/social/display optimization
SEO Manager - Organic acquisition and technical SEO
Affiliate/Partnerships Manager - Co-marketing and channel partnerships

Core KPIs by Role

Demand Gen: MQL/SQL volume, cost per opportunity, marketing-sourced pipeline $, pipeline velocity, MQL→SQL conversion rate

Markitdown

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

MarkItDown - File to Markdown Conversion

Overview

MarkItDown is a Python tool developed by Microsoft for converting various file formats to Markdown. It’s particularly useful for converting documents into LLM-friendly text format, as Markdown is token-efficient and well-understood by modern language models.

Key Benefits:

Convert documents to clean, structured Markdown
Token-efficient format for LLM processing
Supports 15+ file formats
Optional AI-enhanced image descriptions
OCR for images and scanned documents
Speech transcription for audio files

Visual Enhancement with Scientific Schematics

When creating documents with this skill, always consider adding scientific diagrams and schematics to enhance visual communication.

Material Component Doc

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

FlowGram 文档的组织结构

英文文档: apps/docs/src/en
中文文档: apps/docs/src/zh
Story 组件: apps/docs/components/form-materials/components
物料源码: packages/materials/form-materials/src/components
文档模板: ./templates/material.mdx

组件物料文档撰写流程

1. 源码定位

在 packages/materials/form-materials/src/components 目录下确认物料源代码地址。

操作：

使用 Glob 工具搜索物料文件
确认目录结构（是否有 hooks.ts, context.tsx 等）
记录导出名称和文件路径

2. 需求收集

向用户询问物料使用实例和具体需求。

收集信息：

主要使用场景
典型代码示例（1-2 个）
特殊配置或高级用法
是否需要配图

3. 功能分析

深入阅读源代码，理解物料功能。

分析要点：

Props 接口（类型、默认值、描述）
核心功能和实现方式
依赖关系（FlowGram API、其他物料、第三方库）
Hooks 和 Context
特殊逻辑（条件渲染、副作用等）

4. Story 创建

在 apps/docs/components/form-materials/components 下创建 Story 组件（详见下方 Story 规范）。

5. 文档撰写

基于模板 ./templates/material.mdx 撰写完整文档。

文档位置：

中文：apps/docs/src/zh/materials/components/{物料名称}.mdx
英文：apps/docs/src/en/materials/components/{物料名称}.mdx（翻译后）

6. 质量检查

检查清单：

Mcp Integration

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

MCP Integration for Claude Code Plugins

Overview

Model Context Protocol (MCP) enables Claude Code plugins to integrate with external services and APIs by providing structured tool access. Use MCP integration to expose external service capabilities as tools within Claude Code.

Key capabilities:

Connect to external services (databases, APIs, file systems)
Provide 10+ related tools from a single service
Handle OAuth and complex authentication flows
Bundle MCP servers with plugins for automatic setup

MCP Server Configuration Methods

Plugins can bundle MCP servers in two ways:

Memory Forensics

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

Memory Forensics

Comprehensive techniques for acquiring, analyzing, and extracting artifacts from memory dumps for incident response and malware analysis.

Memory Acquisition

Live Acquisition Tools

Windows

 1# WinPmem (Recommended)
 2winpmem_mini_x64.exe memory.raw
 3
 4# DumpIt
 5DumpIt.exe
 6
 7# Belkasoft RAM Capturer
 8# GUI-based, outputs raw format
 9
10# Magnet RAM Capture
11# GUI-based, outputs raw format

Linux

1# LiME (Linux Memory Extractor)
2sudo insmod lime.ko "path=/tmp/memory.lime format=lime"
3
4# /dev/mem (limited, requires permissions)
5sudo dd if=/dev/mem of=memory.raw bs=1M
6
7# /proc/kcore (ELF format)
8sudo cp /proc/kcore memory.elf

macOS

1# osxpmem
2sudo ./osxpmem -o memory.raw
3
4# MacQuisition (commercial)

Virtual Machine Memory

 1# VMware: .vmem file is raw memory
 2cp vm.vmem memory.raw
 3
 4# VirtualBox: Use debug console
 5vboxmanage debugvm "VMName" dumpvmcore --filename memory.elf
 6
 7# QEMU
 8virsh dump <domain> memory.raw --memory-only
 9
10# Hyper-V
11# Checkpoint contains memory state

Volatility 3 Framework

Installation and Setup

 1# Install Volatility 3
 2pip install volatility3
 3
 4# Install symbol tables (Windows)
 5# Download from https://downloads.volatilityfoundation.org/volatility3/symbols/
 6
 7# Basic usage
 8vol -f memory.raw <plugin>
 9
10# With symbol path
11vol -f memory.raw -s /path/to/symbols windows.pslist

Essential Plugins

Process Analysis

 1# List processes
 2vol -f memory.raw windows.pslist
 3
 4# Process tree (parent-child relationships)
 5vol -f memory.raw windows.pstree
 6
 7# Hidden process detection
 8vol -f memory.raw windows.psscan
 9
10# Process memory dumps
11vol -f memory.raw windows.memmap --pid <PID> --dump
12
13# Process environment variables
14vol -f memory.raw windows.envars --pid <PID>
15
16# Command line arguments
17vol -f memory.raw windows.cmdline

Network Analysis

1# Network connections
2vol -f memory.raw windows.netscan
3
4# Network connection state
5vol -f memory.raw windows.netstat

DLL and Module Analysis

 1# Loaded DLLs per process
 2vol -f memory.raw windows.dlllist --pid <PID>
 3
 4# Find hidden/injected DLLs
 5vol -f memory.raw windows.ldrmodules
 6
 7# Kernel modules
 8vol -f memory.raw windows.modules
 9
10# Module dumps
11vol -f memory.raw windows.moddump --pid <PID>

Memory Injection Detection

1# Detect code injection
2vol -f memory.raw windows.malfind
3
4# VAD (Virtual Address Descriptor) analysis
5vol -f memory.raw windows.vadinfo --pid <PID>
6
7# Dump suspicious memory regions
8vol -f memory.raw windows.vadyarascan --yara-rules rules.yar

Registry Analysis

1# List registry hives
2vol -f memory.raw windows.registry.hivelist
3
4# Print registry key
5vol -f memory.raw windows.registry.printkey --key "Software\Microsoft\Windows\CurrentVersion\Run"
6
7# Dump registry hive
8vol -f memory.raw windows.registry.hivescan --dump

File System Artifacts

1# Scan for file objects
2vol -f memory.raw windows.filescan
3
4# Dump files from memory
5vol -f memory.raw windows.dumpfiles --pid <PID>
6
7# MFT analysis
8vol -f memory.raw windows.mftscan

Linux Analysis

 1# Process listing
 2vol -f memory.raw linux.pslist
 3
 4# Process tree
 5vol -f memory.raw linux.pstree
 6
 7# Bash history
 8vol -f memory.raw linux.bash
 9
10# Network connections
11vol -f memory.raw linux.sockstat
12
13# Loaded kernel modules
14vol -f memory.raw linux.lsmod
15
16# Mount points
17vol -f memory.raw linux.mount
18
19# Environment variables
20vol -f memory.raw linux.envars

macOS Analysis

 1# Process listing
 2vol -f memory.raw mac.pslist
 3
 4# Process tree
 5vol -f memory.raw mac.pstree
 6
 7# Network connections
 8vol -f memory.raw mac.netstat
 9
10# Kernel extensions
11vol -f memory.raw mac.lsmod

Analysis Workflows

Malware Analysis Workflow

 1# 1. Initial process survey
 2vol -f memory.raw windows.pstree > processes.txt
 3vol -f memory.raw windows.pslist > pslist.txt
 4
 5# 2. Network connections
 6vol -f memory.raw windows.netscan > network.txt
 7
 8# 3. Detect injection
 9vol -f memory.raw windows.malfind > malfind.txt
10
11# 4. Analyze suspicious processes
12vol -f memory.raw windows.dlllist --pid <PID>
13vol -f memory.raw windows.handles --pid <PID>
14
15# 5. Dump suspicious executables
16vol -f memory.raw windows.pslist --pid <PID> --dump
17
18# 6. Extract strings from dumps
19strings -a pid.<PID>.exe > strings.txt
20
21# 7. YARA scanning
22vol -f memory.raw windows.yarascan --yara-rules malware.yar

Incident Response Workflow

 1# 1. Timeline of events
 2vol -f memory.raw windows.timeliner > timeline.csv
 3
 4# 2. User activity
 5vol -f memory.raw windows.cmdline
 6vol -f memory.raw windows.consoles
 7
 8# 3. Persistence mechanisms
 9vol -f memory.raw windows.registry.printkey \
10 --key "Software\Microsoft\Windows\CurrentVersion\Run"
11
12# 4. Services
13vol -f memory.raw windows.svcscan
14
15# 5. Scheduled tasks
16vol -f memory.raw windows.scheduled_tasks
17
18# 6. Recent files
19vol -f memory.raw windows.filescan | grep -i "recent"

Data Structures

Windows Process Structures

 1// EPROCESS (Executive Process)
 2typedef struct _EPROCESS {
 3 KPROCESS Pcb; // Kernel process block
 4 EX_PUSH_LOCK ProcessLock;
 5 LARGE_INTEGER CreateTime;
 6 LARGE_INTEGER ExitTime;
 7 // ...
 8 LIST_ENTRY ActiveProcessLinks; // Doubly-linked list
 9 ULONG_PTR UniqueProcessId; // PID
10 // ...
11 PEB* Peb; // Process Environment Block
12 // ...
13} EPROCESS;
14
15// PEB (Process Environment Block)
16typedef struct _PEB {
17 BOOLEAN InheritedAddressSpace;
18 BOOLEAN ReadImageFileExecOptions;
19 BOOLEAN BeingDebugged; // Anti-debug check
20 // ...
21 PVOID ImageBaseAddress; // Base address of executable
22 PPEB_LDR_DATA Ldr; // Loader data (DLL list)
23 PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
24 // ...
25} PEB;

VAD (Virtual Address Descriptor)

 1typedef struct _MMVAD {
 2 MMVAD_SHORT Core;
 3 union {
 4 ULONG LongFlags;
 5 MMVAD_FLAGS VadFlags;
 6 } u;
 7 // ...
 8 PVOID FirstPrototypePte;
 9 PVOID LastContiguousPte;
10 // ...
11 PFILE_OBJECT FileObject;
12} MMVAD;
13
14// Memory protection flags
15#define PAGE_EXECUTE 0x10
16#define PAGE_EXECUTE_READ 0x20
17#define PAGE_EXECUTE_READWRITE 0x40
18#define PAGE_EXECUTE_WRITECOPY 0x80

Detection Patterns

Process Injection Indicators

 1# Malfind indicators
 2# - PAGE_EXECUTE_READWRITE protection (suspicious)
 3# - MZ header in non-image VAD region
 4# - Shellcode patterns at allocation start
 5
 6# Common injection techniques
 7# 1. Classic DLL Injection
 8# - VirtualAllocEx + WriteProcessMemory + CreateRemoteThread
 9
10# 2. Process Hollowing
11# - CreateProcess (SUSPENDED) + NtUnmapViewOfSection + WriteProcessMemory
12
13# 3. APC Injection
14# - QueueUserAPC targeting alertable threads
15
16# 4. Thread Execution Hijacking
17# - SuspendThread + SetThreadContext + ResumeThread

Rootkit Detection

 1# Compare process lists
 2vol -f memory.raw windows.pslist > pslist.txt
 3vol -f memory.raw windows.psscan > psscan.txt
 4diff pslist.txt psscan.txt # Hidden processes
 5
 6# Check for DKOM (Direct Kernel Object Manipulation)
 7vol -f memory.raw windows.callbacks
 8
 9# Detect hooked functions
10vol -f memory.raw windows.ssdt # System Service Descriptor Table
11
12# Driver analysis
13vol -f memory.raw windows.driverscan
14vol -f memory.raw windows.driverirp

Credential Extraction

 1# Dump hashes (requires hivelist first)
 2vol -f memory.raw windows.hashdump
 3
 4# LSA secrets
 5vol -f memory.raw windows.lsadump
 6
 7# Cached domain credentials
 8vol -f memory.raw windows.cachedump
 9
10# Mimikatz-style extraction
11# Requires specific plugins/tools

YARA Integration

Writing Memory YARA Rules

rule Suspicious_Injection
{
 meta:
 description = "Detects common injection shellcode"

 strings:
 // Common shellcode patterns
 $mz = { 4D 5A }
 $shellcode1 = { 55 8B EC 83 EC } // Function prologue
 $api_hash = { 68 ?? ?? ?? ?? 68 ?? ?? ?? ?? E8 } // Push hash, call

 condition:
 $mz at 0 or any of ($shellcode*)
}

rule Cobalt_Strike_Beacon
{
 meta:
 description = "Detects Cobalt Strike beacon in memory"

 strings:
 $config = { 00 01 00 01 00 02 }
 $sleep = "sleeptime"
 $beacon = "%s (admin)" wide

 condition:
 2 of them
}

Scanning Memory

1# Scan all process memory
2vol -f memory.raw windows.yarascan --yara-rules rules.yar
3
4# Scan specific process
5vol -f memory.raw windows.yarascan --yara-rules rules.yar --pid 1234
6
7# Scan kernel memory
8vol -f memory.raw windows.yarascan --yara-rules rules.yar --kernel

String Analysis

Extracting Strings

 1# Basic string extraction
 2strings -a memory.raw > all_strings.txt
 3
 4# Unicode strings
 5strings -el memory.raw >> all_strings.txt
 6
 7# Targeted extraction from process dump
 8vol -f memory.raw windows.memmap --pid 1234 --dump
 9strings -a pid.1234.dmp > process_strings.txt
10
11# Pattern matching
12grep -E "(https?://|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})" all_strings.txt

FLOSS for Obfuscated Strings

1# FLOSS extracts obfuscated strings
2floss malware.exe > floss_output.txt
3
4# From memory dump
5floss pid.1234.dmp

Best Practices

Acquisition Best Practices

Minimize footprint: Use lightweight acquisition tools
Document everything: Record time, tool, and hash of capture
Verify integrity: Hash memory dump immediately after capture
Chain of custody: Maintain proper forensic handling

Analysis Best Practices

Start broad: Get overview before deep diving
Cross-reference: Use multiple plugins for same data
Timeline correlation: Correlate memory findings with disk/network
Document findings: Keep detailed notes and screenshots
Validate results: Verify findings through multiple methods

Common Pitfalls

Stale data: Memory is volatile, analyze promptly
Incomplete dumps: Verify dump size matches expected RAM
Symbol issues: Ensure correct symbol files for OS version
Smear: Memory may change during acquisition
Encryption: Some data may be encrypted in memory

Microservices Patterns

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

Microservices Patterns

Master microservices architecture patterns including service boundaries, inter-service communication, data management, and resilience patterns for building distributed systems.

When to Use This Skill

Decomposing monoliths into microservices
Designing service boundaries and contracts
Implementing inter-service communication
Managing distributed data and transactions
Building resilient distributed systems
Implementing service discovery and load balancing
Designing event-driven architectures

Core Concepts

1. Service Decomposition Strategies

By Business Capability

Organize services around business functions
Each service owns its domain
Example: OrderService, PaymentService, InventoryService

By Subdomain (DDD)

Migrating To Vendure Dashboard

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

Vendure Dashboard Migration

Instructions

If not explicitly stated by the user, find out which plugin they want to migrate.
Read and understand the overall rules for migration
- ./01-general.md
- ./01a-common-tasks.md
Check the tsconfig setup
. This may or may not already be set up.
- ./01b-tsconfig-setup.md
Identify each part of the Admin UI extensions that needs to be migrated, and use the data from the appropriate sections to guide the migration:
- ./02-forms.md
- ./03-custom-field-inputs.md
- ./04-list-pages.md
- ./05-detail-pages.md
- ./06-adding-nav-menu-items.md
- ./07-action-bar-items.md
- ./08-custom-detail-components.md
- ./09-page-tabs.md
- ./10-widgets.md
Ensure you have followed the instructions marked “Important” for each section

Modal

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

Overview

Modal is a serverless platform for running Python code in the cloud with minimal configuration. Execute functions on powerful GPUs, scale automatically to thousands of containers, and pay only for compute used.

Modal is particularly suited for AI/ML workloads, high-performance batch processing, scheduled jobs, GPU inference, and serverless APIs. Sign up for free at https://modal.com and receive $30/month in credits.

When to Use This Skill

Use Modal for:

Deploying and serving ML models (LLMs, image generation, embedding models)
Running GPU-accelerated computation (training, inference, rendering)
Batch processing large datasets in parallel
Scheduling compute-intensive jobs (daily data processing, model training)
Building serverless APIs that need automatic scaling
Scientific computing requiring distributed compute or specialized hardware

Authentication and Setup

Modal requires authentication via API token.

Modern Javascript Patterns

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

Modern JavaScript Patterns

Comprehensive guide for mastering modern JavaScript (ES6+) features, functional programming patterns, and best practices for writing clean, maintainable, and performant code.

When to Use This Skill

Refactoring legacy JavaScript to modern syntax
Implementing functional programming patterns
Optimizing JavaScript performance
Writing maintainable and readable code
Working with asynchronous operations
Building modern web applications
Migrating from callbacks to Promises/async-await
Implementing data transformation pipelines

ES6+ Core Features

1. Arrow Functions

Syntax and Use Cases:

Monorepo Management

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

Monorepo Management

Build efficient, scalable monorepos that enable code sharing, consistent tooling, and atomic changes across multiple packages and applications.

When to Use This Skill

Setting up new monorepo projects
Migrating from multi-repo to monorepo
Optimizing build and test performance
Managing shared dependencies
Implementing code sharing strategies
Setting up CI/CD for monorepos
Versioning and publishing packages
Debugging monorepo-specific issues

Core Concepts

1. Why Monorepos?

Advantages:

Shared code and dependencies
Atomic commits across projects
Consistent tooling and standards
Easier refactoring
Simplified dependency management
Better code visibility

Challenges:

Move Code Quality

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

Move Code Quality Checker

You are an expert Move language code reviewer with deep knowledge of the Move Book Code Quality Checklist. Your role is to analyze Move packages and provide specific, actionable feedback based on modern Move 2024 Edition best practices.

When to Use This Skill

Activate this skill when:

User asks to “check Move code quality”, “review Move code”, or “analyze Move package”
User mentions Move 2024 Edition compliance
Working in a directory containing .move files or Move.toml
User asks to review code against the Move checklist

Analysis Workflow

Phase 1: Discovery

Detect Move project structure

N8N Code Javascript

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

JavaScript Code Node

Expert guidance for writing JavaScript code in n8n Code nodes.

Quick Start

 1// Basic template for Code nodes
 2const items = $input.all();
 3
 4// Process data
 5const processed = items.map(item => ({
 6 json: {
 7 ...item.json,
 8 processed: true,
 9 timestamp: new Date().toISOString()
10 }
11}));
12
13return processed;

Essential Rules

Choose “Run Once for All Items” mode (recommended for most use cases)
Access data: $input.all(), $input.first(), or $input.item
CRITICAL: Must return [{json: {...}}] format
CRITICAL: Webhook data is under $json.body (not $json directly)
Built-ins available: $helpers.httpRequest(), DateTime (Luxon), $jmespath()

Mode Selection Guide

The Code node offers two execution modes. Choose based on your use case:

N8N Code Python

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

Python Code Node (Beta)

Expert guidance for writing Python code in n8n Code nodes.

⚠️ Important: JavaScript First

Recommendation: Use JavaScript for 95% of use cases. Only use Python when:

You need specific Python standard library functions
You’re significantly more comfortable with Python syntax
You’re doing data transformations better suited to Python

Why JavaScript is preferred:

Full n8n helper functions ($helpers.httpRequest, etc.)
Luxon DateTime library for advanced date/time operations
No external library limitations
Better n8n documentation and community support

Quick Start

 1# Basic template for Python Code nodes
 2items = _input.all()
 3
 4# Process data
 5processed = []
 6for item in items:
 7 processed.append({
 8 "json": {
 9 **item["json"],
10 "processed": True,
11 "timestamp": datetime.now().isoformat()
12 }
13 })
14
15return processed

Essential Rules

Consider JavaScript first - Use Python only when necessary
Access data: _input.all(), _input.first(), or _input.item
CRITICAL: Must return [{"json": {...}}] format
CRITICAL: Webhook data is under _json["body"] (not _json directly)
CRITICAL LIMITATION: No external libraries (no requests, pandas, numpy)
Standard library only: json, datetime, re, base64, hashlib, urllib.parse, math, random, statistics

Mode Selection Guide

Same as JavaScript - choose based on your use case:

N8N Expression Syntax

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

n8n Expression Syntax

Expert guide for writing correct n8n expressions in workflows.

Expression Format

All dynamic content in n8n uses double curly braces:

{{expression}}

Examples:

✅ {{$json.email}}
✅ {{$json.body.name}}
✅ {{$node["HTTP Request"].json.data}}
❌ $json.email (no braces - treated as literal text)
❌ {$json.email} (single braces - invalid)

Core Variables

$json - Current Node Output

Access data from the current node:

1{{$json.fieldName}}
2{{$json['field with spaces']}}
3{{$json.nested.property}}
4{{$json.items[0].name}}

$node - Reference Other Nodes

Access data from any previous node:

N8N Mcp Tools Expert

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

n8n MCP Tools Expert

Master guide for using n8n-mcp MCP server tools to build workflows.

Tool Categories

n8n-mcp provides 40+ tools organized into categories:

Node Discovery → SEARCH_GUIDE.md
Configuration Validation → VALIDATION_GUIDE.md
Workflow Management → WORKFLOW_GUIDE.md
Template Library - Search and access 2,653 real workflows
Documentation - Get tool and node documentation

Quick Reference

Most Used Tools (by success rate)

Tool	Use When	Success Rate	Speed
`search_nodes`	Finding nodes by keyword	99.9%	<20ms
`get_node_essentials`	Understanding node operations	91.7%	<10ms
`validate_node_operation`	Checking configurations	Varies	<100ms
`n8n_create_workflow`	Creating workflows	96.8%	100-500ms
`n8n_update_partial_workflow`	Editing workflows (MOST USED!)	99.0%	50-200ms
`validate_workflow`	Checking complete workflow	95.5%	100-500ms

Tool Selection Guide

Finding the Right Node

Workflow:

N8N Node Configuration

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

n8n Node Configuration

Expert guidance for operation-aware node configuration with property dependencies.

Configuration Philosophy

Progressive disclosure: Start minimal, add complexity as needed

Configuration best practices:

get_node_essentials is the most used discovery pattern
56 seconds average between configuration edits
91.7% success rate with essentials-based configuration

Key insight: Most configurations need only essentials, not full schema!

Core Concepts

1. Operation-Aware Configuration

Not all fields are always required - it depends on operation!

N8N Workflow Patterns

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

n8n Workflow Patterns

Proven architectural patterns for building n8n workflows.

The 5 Core Patterns

Based on analysis of real workflow usage:

Webhook Processing (Most Common)
- Receive HTTP requests → Process → Output
- Pattern: Webhook → Validate → Transform → Respond/Notify
HTTP API Integration
- Fetch from REST APIs → Transform → Store/Use
- Pattern: Trigger → HTTP Request → Transform → Action → Error Handler
Database Operations
- Read/Write/Sync database data
- Pattern: Schedule → Query → Transform → Write → Verify
AI Agent Workflow

Nextjs 15

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

App Router File Conventions

app/
├── layout.tsx # Root layout (required)
├── page.tsx # Home page (/)
├── loading.tsx # Loading UI (Suspense)
├── error.tsx # Error boundary
├── not-found.tsx # 404 page
├── (auth)/ # Route group (no URL impact)
│ ├── login/page.tsx # /login
│ └── signup/page.tsx # /signup
├── api/
│ └── route.ts # API handler
└── _components/ # Private folder (not routed)

Server Components (Default)

1// No directive needed - async by default
2export default async function Page() {
3 const data = await db.query();
4 return <Component data={data} />;
5}

Server Actions

 1// app/actions.ts
 2"use server";
 3
 4import { revalidatePath } from "next/cache";
 5import { redirect } from "next/navigation";
 6
 7export async function createUser(formData: FormData) {
 8 const name = formData.get("name") as string;
 9
10 await db.users.create({ data: { name } });
11
12 revalidatePath("/users");
13 redirect("/users");
14}
15
16// Usage
17<form action={createUser}>
18 <input name="name" required />
19 <button type="submit">Create</button>
20</form>

Data Fetching

 1// Parallel
 2async function Page() {
 3 const [users, posts] = await Promise.all([
 4 getUsers(),
 5 getPosts(),
 6 ]);
 7 return <Dashboard users={users} posts={posts} />;
 8}
 9
10// Streaming with Suspense
11<Suspense fallback={<Loading />}>
12 <SlowComponent />
13</Suspense>

Route Handlers (API)

 1// app/api/users/route.ts
 2import { NextRequest, NextResponse } from "next/server";
 3
 4export async function GET(request: NextRequest) {
 5 const users = await db.users.findMany();
 6 return NextResponse.json(users);
 7}
 8
 9export async function POST(request: NextRequest) {
10 const body = await request.json();
11 const user = await db.users.create({ data: body });
12 return NextResponse.json(user, { status: 201 });
13}

Middleware

 1// middleware.ts (root level)
 2import { NextResponse } from "next/server";
 3import type { NextRequest } from "next/server";
 4
 5export function middleware(request: NextRequest) {
 6 const token = request.cookies.get("token");
 7
 8 if (!token && request.nextUrl.pathname.startsWith("/dashboard")) {
 9 return NextResponse.redirect(new URL("/login", request.url));
10 }
11
12 return NextResponse.next();
13}
14
15export const config = {
16 matcher: ["/dashboard/:path*"],
17};

Metadata

 1// Static
 2export const metadata = {
 3 title: "My App",
 4 description: "Description",
 5};
 6
 7// Dynamic
 8export async function generateMetadata({ params }) {
 9 const product = await getProduct(params.id);
10 return { title: product.name };
11}

server-only Package

1import "server-only";
2
3// This will error if imported in client component
4export async function getSecretData() {
5 return db.secrets.findMany();
6}

Nextjs App Router Patterns

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

Next.js App Router Patterns

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

When to Use This Skill

Building new Next.js applications with App Router
Migrating from Pages Router to App Router
Implementing Server Components and streaming
Setting up parallel and intercepting routes
Optimizing data fetching and caching
Building full-stack features with Server Actions

Core Concepts

1. Rendering Modes

Mode	Where	When to Use
Server Components	Server only	Data fetching, heavy computation, secrets
Client Components	Browser	Interactivity, hooks, browser APIs
Static	Build time	Content that rarely changes
Dynamic	Request time	Personalized or real-time data
Streaming	Progressive	Large pages, slow data sources

2. File Conventions

app/
├── layout.tsx # Shared UI wrapper
├── page.tsx # Route UI
├── loading.tsx # Loading UI (Suspense)
├── error.tsx # Error boundary
├── not-found.tsx # 404 UI
├── route.ts # API endpoint
├── template.tsx # Re-mounted layout
├── default.tsx # Parallel route fallback
└── opengraph-image.tsx # OG image generation

Quick Start

 1// app/layout.tsx
 2import { Inter } from 'next/font/google'
 3import { Providers } from './providers'
 4
 5const inter = Inter({ subsets: ['latin'] })
 6
 7export const metadata = {
 8 title: { default: 'My App', template: '%s | My App' },
 9 description: 'Built with Next.js App Router',
10}
11
12export default function RootLayout({
13 children,
14}: {
15 children: React.ReactNode
16}) {
17 return (
18 <html lang="en" suppressHydrationWarning>
19 <body className={inter.className}>
20 <Providers>{children}</Providers>
21 </body>
22 </html>
23 )
24}
25
26// app/page.tsx - Server Component by default
27async function getProducts() {
28 const res = await fetch('https://api.example.com/products', {
29 next: { revalidate: 3600 }, // ISR: revalidate every hour
30 })
31 return res.json()
32}
33
34export default async function HomePage() {
35 const products = await getProducts()
36
37 return (
38 <main>
39 <h1>Products</h1>
40 <ProductGrid products={products} />
41 </main>
42 )
43}

Patterns

Pattern 1: Server Components with Data Fetching

 1// app/products/page.tsx
 2import { Suspense } from 'react'
 3import { ProductList, ProductListSkeleton } from '@/components/products'
 4import { FilterSidebar } from '@/components/filters'
 5
 6interface SearchParams {
 7 category?: string
 8 sort?: 'price' | 'name' | 'date'
 9 page?: string
10}
11
12export default async function ProductsPage({
13 searchParams,
14}: {
15 searchParams: Promise<SearchParams>
16}) {
17 const params = await searchParams
18
19 return (
20 <div className="flex gap-8">
21 <FilterSidebar />
22 <Suspense
23 key={JSON.stringify(params)}
24 fallback={<ProductListSkeleton />}
25 >
26 <ProductList
27 category={params.category}
28 sort={params.sort}
29 page={Number(params.page) || 1}
30 />
31 </Suspense>
32 </div>
33 )
34}
35
36// components/products/ProductList.tsx - Server Component
37async function getProducts(filters: ProductFilters) {
38 const res = await fetch(
39 `${process.env.API_URL}/products?${new URLSearchParams(filters)}`,
40 { next: { tags: ['products'] } }
41 )
42 if (!res.ok) throw new Error('Failed to fetch products')
43 return res.json()
44}
45
46export async function ProductList({ category, sort, page }: ProductFilters) {
47 const { products, totalPages } = await getProducts({ category, sort, page })
48
49 return (
50 <div>
51 <div className="grid grid-cols-3 gap-4">
52 {products.map((product) => (
53 <ProductCard key={product.id} product={product} />
54 ))}
55 </div>
56 <Pagination currentPage={page} totalPages={totalPages} />
57 </div>
58 )
59}

Pattern 2: Client Components with ‘use client’

 1// components/products/AddToCartButton.tsx
 2'use client'
 3
 4import { useState, useTransition } from 'react'
 5import { addToCart } from '@/app/actions/cart'
 6
 7export function AddToCartButton({ productId }: { productId: string }) {
 8 const [isPending, startTransition] = useTransition()
 9 const [error, setError] = useState<string | null>(null)
10
11 const handleClick = () => {
12 setError(null)
13 startTransition(async () => {
14 const result = await addToCart(productId)
15 if (result.error) {
16 setError(result.error)
17 }
18 })
19 }
20
21 return (
22 <div>
23 <button
24 onClick={handleClick}
25 disabled={isPending}
26 className="btn-primary"
27 >
28 {isPending ? 'Adding...' : 'Add to Cart'}
29 </button>
30 {error && <p className="text-red-500 text-sm">{error}</p>}
31 </div>
32 )
33}

Pattern 3: Server Actions

 1// app/actions/cart.ts
 2"use server";
 3
 4import { revalidateTag } from "next/cache";
 5import { cookies } from "next/headers";
 6import { redirect } from "next/navigation";
 7
 8export async function addToCart(productId: string) {
 9 const cookieStore = await cookies();
10 const sessionId = cookieStore.get("session")?.value;
11
12 if (!sessionId) {
13 redirect("/login");
14 }
15
16 try {
17 await db.cart.upsert({
18 where: { sessionId_productId: { sessionId, productId } },
19 update: { quantity: { increment: 1 } },
20 create: { sessionId, productId, quantity: 1 },
21 });
22
23 revalidateTag("cart");
24 return { success: true };
25 } catch (error) {
26 return { error: "Failed to add item to cart" };
27 }
28}
29
30export async function checkout(formData: FormData) {
31 const address = formData.get("address") as string;
32 const payment = formData.get("payment") as string;
33
34 // Validate
35 if (!address || !payment) {
36 return { error: "Missing required fields" };
37 }
38
39 // Process order
40 const order = await processOrder({ address, payment });
41
42 // Redirect to confirmation
43 redirect(`/orders/${order.id}/confirmation`);
44}

Pattern 4: Parallel Routes

 1// app/dashboard/layout.tsx
 2export default function DashboardLayout({
 3 children,
 4 analytics,
 5 team,
 6}: {
 7 children: React.ReactNode
 8 analytics: React.ReactNode
 9 team: React.ReactNode
10}) {
11 return (
12 <div className="dashboard-grid">
13 <main>{children}</main>
14 <aside className="analytics-panel">{analytics}</aside>
15 <aside className="team-panel">{team}</aside>
16 </div>
17 )
18}
19
20// app/dashboard/@analytics/page.tsx
21export default async function AnalyticsSlot() {
22 const stats = await getAnalytics()
23 return <AnalyticsChart data={stats} />
24}
25
26// app/dashboard/@analytics/loading.tsx
27export default function AnalyticsLoading() {
28 return <ChartSkeleton />
29}
30
31// app/dashboard/@team/page.tsx
32export default async function TeamSlot() {
33 const members = await getTeamMembers()
34 return <TeamList members={members} />
35}

 1// File structure for photo modal
 2// app/
 3// ├── @modal/
 4// │ ├── (.)photos/[id]/page.tsx # Intercept
 5// │ └── default.tsx
 6// ├── photos/
 7// │ └── [id]/page.tsx # Full page
 8// └── layout.tsx
 9
10// app/@modal/(.)photos/[id]/page.tsx
11import { Modal } from '@/components/Modal'
12import { PhotoDetail } from '@/components/PhotoDetail'
13
14export default async function PhotoModal({
15 params,
16}: {
17 params: Promise<{ id: string }>
18}) {
19 const { id } = await params
20 const photo = await getPhoto(id)
21
22 return (
23 <Modal>
24 <PhotoDetail photo={photo} />
25 </Modal>
26 )
27}
28
29// app/photos/[id]/page.tsx - Full page version
30export default async function PhotoPage({
31 params,
32}: {
33 params: Promise<{ id: string }>
34}) {
35 const { id } = await params
36 const photo = await getPhoto(id)
37
38 return (
39 <div className="photo-page">
40 <PhotoDetail photo={photo} />
41 <RelatedPhotos photoId={id} />
42 </div>
43 )
44}
45
46// app/layout.tsx
47export default function RootLayout({
48 children,
49 modal,
50}: {
51 children: React.ReactNode
52 modal: React.ReactNode
53}) {
54 return (
55 <html>
56 <body>
57 {children}
58 {modal}
59 </body>
60 </html>
61 )
62}

Pattern 6: Streaming with Suspense

 1// app/product/[id]/page.tsx
 2import { Suspense } from 'react'
 3
 4export default async function ProductPage({
 5 params,
 6}: {
 7 params: Promise<{ id: string }>
 8}) {
 9 const { id } = await params
10
11 // This data loads first (blocking)
12 const product = await getProduct(id)
13
14 return (
15 <div>
16 {/* Immediate render */}
17 <ProductHeader product={product} />
18
19 {/* Stream in reviews */}
20 <Suspense fallback={<ReviewsSkeleton />}>
21 <Reviews productId={id} />
22 </Suspense>
23
24 {/* Stream in recommendations */}
25 <Suspense fallback={<RecommendationsSkeleton />}>
26 <Recommendations productId={id} />
27 </Suspense>
28 </div>
29 )
30}
31
32// These components fetch their own data
33async function Reviews({ productId }: { productId: string }) {
34 const reviews = await getReviews(productId) // Slow API
35 return <ReviewList reviews={reviews} />
36}
37
38async function Recommendations({ productId }: { productId: string }) {
39 const products = await getRecommendations(productId) // ML-based, slow
40 return <ProductCarousel products={products} />
41}

Pattern 7: Route Handlers (API Routes)

 1// app/api/products/route.ts
 2import { NextRequest, NextResponse } from "next/server";
 3
 4export async function GET(request: NextRequest) {
 5 const searchParams = request.nextUrl.searchParams;
 6 const category = searchParams.get("category");
 7
 8 const products = await db.product.findMany({
 9 where: category ? { category } : undefined,
10 take: 20,
11 });
12
13 return NextResponse.json(products);
14}
15
16export async function POST(request: NextRequest) {
17 const body = await request.json();
18
19 const product = await db.product.create({
20 data: body,
21 });
22
23 return NextResponse.json(product, { status: 201 });
24}
25
26// app/api/products/[id]/route.ts
27export async function GET(
28 request: NextRequest,
29 { params }: { params: Promise<{ id: string }> },
30) {
31 const { id } = await params;
32 const product = await db.product.findUnique({ where: { id } });
33
34 if (!product) {
35 return NextResponse.json({ error: "Product not found" }, { status: 404 });
36 }
37
38 return NextResponse.json(product);
39}

Pattern 8: Metadata and SEO

 1// app/products/[slug]/page.tsx
 2import { Metadata } from 'next'
 3import { notFound } from 'next/navigation'
 4
 5type Props = {
 6 params: Promise<{ slug: string }>
 7}
 8
 9export async function generateMetadata({ params }: Props): Promise<Metadata> {
10 const { slug } = await params
11 const product = await getProduct(slug)
12
13 if (!product) return {}
14
15 return {
16 title: product.name,
17 description: product.description,
18 openGraph: {
19 title: product.name,
20 description: product.description,
21 images: [{ url: product.image, width: 1200, height: 630 }],
22 },
23 twitter: {
24 card: 'summary_large_image',
25 title: product.name,
26 description: product.description,
27 images: [product.image],
28 },
29 }
30}
31
32export async function generateStaticParams() {
33 const products = await db.product.findMany({ select: { slug: true } })
34 return products.map((p) => ({ slug: p.slug }))
35}
36
37export default async function ProductPage({ params }: Props) {
38 const { slug } = await params
39 const product = await getProduct(slug)
40
41 if (!product) notFound()
42
43 return <ProductDetail product={product} />
44}

Caching Strategies

Data Cache

 1// No cache (always fresh)
 2fetch(url, { cache: "no-store" });
 3
 4// Cache forever (static)
 5fetch(url, { cache: "force-cache" });
 6
 7// ISR - revalidate after 60 seconds
 8fetch(url, { next: { revalidate: 60 } });
 9
10// Tag-based invalidation
11fetch(url, { next: { tags: ["products"] } });
12
13// Invalidate via Server Action
14("use server");
15import { revalidateTag, revalidatePath } from "next/cache";
16
17export async function updateProduct(id: string, data: ProductData) {
18 await db.product.update({ where: { id }, data });
19 revalidateTag("products");
20 revalidatePath("/products");
21}

Best Practices

Do’s

Start with Server Components - Add ‘use client’ only when needed
Colocate data fetching - Fetch data where it’s used
Use Suspense boundaries - Enable streaming for slow data
Leverage parallel routes - Independent loading states
Use Server Actions - For mutations with progressive enhancement

Don’ts

Don’t pass serializable data - Server → Client boundary limitations
Don’t use hooks in Server Components - No useState, useEffect
Don’t fetch in Client Components - Use Server Components or React Query
Don’t over-nest layouts - Each layout adds to the component tree
Don’t ignore loading states - Always provide loading.tsx or Suspense

All Skills on Agent Skills Hub

微信读书笔记划线

notes — 笔记/划线

接口

/user/notebooks — 笔记本概览（所有有笔记的书）

概念解释

分页规则

/book/bookmarklist — 单本书的划线内容列表（不含书签内容）

微信读书书籍点评

review — 书籍点评

接口

/review/list — 书籍公开点评

工作流

输出格式

微信读书书籍信息

book — 书籍信息与阅读进度

接口

/book/info — 书籍基本信息

/book/chapterinfo — 章节目录

/book/getprogress — 阅读进度

微信读书书架管理

shelf — 书架管理

重要概念

接口

数量口径

微信读书搜索

search — 搜索

接口

微信读书推荐

discover — 发现推荐好书

接口

/book/recommend — 个性化推荐（为你推荐）

/book/similar — 相似书推荐

微信读书用户信息

profile — 用户信息与阅读统计

说明

工作流

1. 获取书架

2. 获取阅读进度

3. 获取笔记

输出格式

微信读书阅读统计

readdata — 阅读统计

接口

/readdata/detail — 阅读统计详情

Agent Builder

Agent Builder

The Core Philosophy

Agent Memory

Agent Memory

Proactive Usage

Agent Review

Agent Review

Running Commands

Options

Available Models

Agile Product Owner

Agile Product Owner

Core Capabilities

Key Scripts

user_story_generator.py

Airflow Dag Patterns

Apache Airflow DAG Patterns

When to Use This Skill

Core Concepts

1. DAG Design Principles

2. Task Dependencies

Quick Start

Patterns

Pattern 1: TaskFlow API (Airflow 2.0+)

Pattern 2: Dynamic DAG Generation

Pattern 3: Branching and Conditional Logic

Pattern 4: Sensors and External Dependencies

Pattern 5: Error Handling and Alerts

Pattern 6: Testing DAGs

Project Structure

Best Practices

Do’s

Don’ts

Resources

`/user/notebooks` — 笔记本概览（所有有笔记的书）

`/book/bookmarklist` — 单本书的划线内容列表（不含书签内容）

`/review/list` — 书籍公开点评

`/book/info` — 书籍基本信息

`/book/chapterinfo` — 章节目录

`/book/getprogress` — 阅读进度

`/book/recommend` — 个性化推荐（为你推荐）

`/book/similar` — 相似书推荐

`/readdata/detail` — 阅读统计详情