Skip to content
Back to search

context-engineering-kit

MarketplaceWorks with Claude CodeGitHub

Hand-crafted collection of advanced context engineering techniques and patterns with minimal token footprint focused on improving agent result quality.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/neolabhq-context-engineering-kit/badge.svg)](/listings/neolabhq-context-engineering-kit)

HTML

<a href="/listings/neolabhq-context-engineering-kit"><img src="/api/listings/neolabhq-context-engineering-kit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Step 1: Install Marketplace and Plugins

<details> <summary>Claude Code</summary>

Open Claude Code and add the Context Engineering Kit marketplace:

/plugin marketplace add NeoLabHQ/context-engineering-kit

This makes all plugins available for installation, but does not load any agents or skills into your context.

Install any plugin — for example, reflexion:

/plugin install reflexion@NeoLabHQ/context-engineering-kit

Each installed plugin loads only its specific agents, commands, and skills into Claude's context.

</details>

<details> <summary>Gemini CLI</summary>

Install the extension directly from the repository:

gemini extensions install https://github.com/NeoLabHQ/context-engineering-kit

**Note:** This installs every plugin's skills and agents as a single bundle — there's no per-plugin selection like Claude Code's. Unfortunately, Gemini CLI does not support per-plugin selection. But you can delete skills and agents that you don't need, after installation.

</details>

<details> <summary>Antigravity CLI</summary>

Install the plugin directly from the repository's `antigravity/` folder — Gemini CLI is not required:

agy plugin install https://github.com/NeoLabHQ/context-engineering-kit/antigravity

**Note:** This installs every plugin's skills and agents as a single bundle — there's no per-plugin selection like Claude Code's. Unfortunately, Antigravity CLI does not support per-plugin selection. But you can delete skills and agents that you don't need, after installation.

</details>

<details> <summary>Cursor, Codex, OpenCode and others</summary>

Run the [vercel-labs/skills](https://github.com/vercel-labs/skills) command in your terminal:

npx skills add NeoLabHQ/context-engineering-kit

You can pick which skills to install.

**Note:** Each provider uses its own agent format and `npx skills` does not support subagents, so this installation method won't provide the full experience.

</details>

<details> <summary>Alternative installation methods</summary>

You can use [OpenSkills](https://github.com/numman-ali/openskills) to install skills by running the following commands:

npx openskills install NeoLabHQ/context-engineering-kit
npx openskills sync

</details>

Step 2: Use Plugin

> claude "implement user authentication"
# Claude implements user authentication, then you can ask it to reflect on implementation

> /reflect
# It analyses results and suggests improvements
# If issues are obvious, it will fix them immediately
# If they are minor, it will suggest improvements that you can respond to
> fix the issues

# If you would like to prevent issues found during reflection from appearing again,
# ask Claude to extract resolution strategies and save the insights to project memory
> /memorize

Alternatively, you can use the `reflect` word in the initial prompt:

> claude "implement user authentication, then reflect"
# Claude implements user authentication,
# then hook automatically runs /reflect

In order to use this hook, you need to have `bun` installed. However, it is not required for the overall command.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 155 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "context-engineering-kit",
  4. "version": "3.10.0",
  5. "description": "Hand-crafted collection of advanced context engineering techniques and patterns with minimal token footprint focused on improving agent result quality.",
  6. "owner": {
  7. "name": "NeoLabHQ",
  8. "email": "vlad.goncharov@neolab.finance"
  9. },
  10. "plugins": [
  11. {
  12. "name": "reflexion",
  13. "description": "Collection of commands that force LLM to reflect on previous response and output. Based on papers like Self-Refine and Reflexion. These techniques improve the output of large language models by introducing feedback and refinement loops.",
  14. "version": "3.0.0",
  15. "author": {
  16. "name": "Vlad Goncharov",
  17. "email": "vlad.goncharov@neolab.finance"
  18. },
  19. "source": "./plugins/reflexion",
  20. "category": "productivity"
  21. },
  22. {
  23. "name": "review",
  24. "description": "Introduce codebase and PR review commands and skills using multiple specialized agents.",
  25. "version": "3.2.0",
  26. "author": {
  27. "name": "Vlad Goncharov",
  28. "email": "vlad.goncharov@neolab.finance"
  29. },
  30. "source": "./plugins/review",
  31. "category": "productivity"
  32. },
  33. {
  34. "name": "git",
  35. "description": "Introduces commands for commit and PRs creation, plus skills for git worktrees and notes.",
  36. "version": "3.2.0",
  37. "author": {
  38. "name": "Vlad Goncharov",
  39. "email": "vlad.goncharov@neolab.finance"
  40. },
  41. "source": "./plugins/git",
  42. "category": "productivity"
  43. },
  44. {
  45. "name": "tdd",
  46. "description": "Introduces commands for test-driven development, common anti-patterns and skills for testing using subagents.",
  47. "version": "3.1.0",
  48. "author": {
  49. "name": "Vlad Goncharov",
  50. "email": "vlad.goncharov@neolab.finance"
  51. },
  52. "source": "./plugins/tdd",
  53. "category": "development"
  54. },
  55. {
  56. "name": "sadd",
  57. "description": "Introduces skills for subagent-driven development, dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates.",
  58. "version": "3.4.0",
  59. "author": {
  60. "name": "Vlad Goncharov",
  61. "email": "vlad.goncharov@neolab.finance"
  62. },
  63. "source": "./plugins/sadd",
  64. "category": "development"
  65. },
  66. {
  67. "name": "ddd",
  68. "description": "Introduces command to update CLAUDE.md with best practices for domain-driven development, focused on quality of code, includes Clean Architecture, SOLID principles, and other design patterns.",
  69. "version": "3.0.0",
  70. "author": {
  71. "name": "Vlad Goncharov",
  72. "email": "vlad.goncharov@neolab.finance"
  73. },
  74. "source": "./plugins/ddd",
  75. "category": "development"
  76. },
  77. {
  78. "name": "sdd",
  79. "description": "Specification Driven Development workflow commands and agents, based on Github Spec Kit and OpenSpec. Uses specialized agents for effective context management and quality review.",
  80. "version": "3.6.0",
  81. "author": {
  82. "name": "Vlad Goncharov",
  83. "email": "vlad.goncharov@neolab.finance"
  84. },
  85. "source": "./plugins/sdd",
  86. "category": "development"
  87. },
  88. {
  89. "name": "kaizen",
  90. "description": "Inspired by Japanese continuous improvement philosophy, Agile and Lean development practices. Introduces commands for analysis of root cause of issues and problems, including 5 Whys, Cause and Effect Analysis, and other techniques.",
  91. "version": "3.0.0",
  92. "author": {
  93. "name": "Vlad Goncharov",
  94. "email": "vlad.goncharov@neolab.finance"
  95. },
  96. "source": "./plugins/kaizen",
  97. "category": "productivity"
  98. },
  99. {
  100. "name": "customaize-agent",
  101. "description": "Commands and skills for writing and refining commands, hooks, skills for Claude Code, includes Anthropic Best Practices and Agent Persuasion Principles that can be useful for sub-agent workflows.",
  102. "version": "3.0.0",
  103. "author": {
  104. "name": "Vlad Goncharov",
  105. "email": "vlad.goncharov@neolab.finance"
  106. },
  107. "source": "./plugins/customaize-agent",
  108. "category": "development"
  109. },
  110. {
  111. "name": "docs",
  112. "description": "Commands for analysing project, writing and refining documentation.",
  113. "version": "3.0.0",
  114. "author": {
  115. "name": "Vlad Goncharov",
  116. "email": "vlad.goncharov@neolab.finance"
  117. },
  118. "source": "./plugins/docs",
  119. "category": "productivity"
  120. },
  121. {
  122. "name": "tech-stack",
  123. "description": "Commands for setup or update of CLAUDE.md file with best practices for specific language or framework.",
  124. "version": "3.0.0",
  125. "author": {
  126. "name": "Vlad Goncharov",
  127. "email": "vlad.goncharov@neolab.finance"
  128. },
  129. "source": "./plugins/tech-stack",
  130. "category": "development"
  131. },
  132. {
  133. "name": "mcp",
  134. "description": "Commands for setup well known MCP server integration if needed and update CLAUDE.md file with requirement to use this MCP server for current project.",
  135. "version": "3.0.0",
  136. "author": {
  137. "name": "Vlad Goncharov",
  138. "email": "vlad.goncharov@neolab.finance"
  139. },
  140. "source": "./plugins/mcp",
  141. "category": "development"
  142. },
  143. {
  144. "name": "fpf",
  145. "description": "First Principles Framework (FPF) for structured reasoning. Implements ADI (Abduction-Deduction-Induction) cycle for hypothesis generation, logical verification, empirical validation, and auditable decision-making.",
  146. "version": "3.0.0",
  147. "author": {
  148. "name": "Vlad Goncharov",
  149. "email": "vlad.goncharov@neolab.finance"
  150. },
  151. "source": "./plugins/fpf",
  152. "category": "development"
  153. }
  154. ]
  155. }
README.md · README · 705 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <a href="https://neolab.gitbook.io/cek/" target="blank"><img src="docs/assets/Context-Engineering-Kit6.png" width="512" alt="Context Engineering Kit - advanced context engineering techniques" /></a>
  3. </p>
  4. <div align="center">
  5. [![License](https://img.shields.io/badge/license-GPL%203.0-blue.svg)](LICENSE)
  6. [![agentskills.io](https://img.shields.io/badge/format-agentskills.io-purple.svg)](https://agentskills.io)
  7. [![Mentioned in Awesome Claude Code](https://awesome.re/mentioned-badge.svg)](https://github.com/hesreallyhim/awesome-claude-code)
  8. Advanced context engineering techniques and patterns for Claude Code, OpenCode, Cursor, Antigravity and more.
  9. [Quick Start](#quick-start) · [Plugins](#plugins-list) · [Github Action](https://neolab.gitbook.io/cek/guides/ci-integration) · [Reference](https://neolab.gitbook.io/cek/reference) · [Docs](https://neolab.gitbook.io/cek/)
  10. </div>
  11. # [Context Engineering Kit](https://neolab.gitbook.io/cek)
  12. A hand-crafted collection of advanced context engineering techniques and patterns with minimal token footprint, focused on improving agent result quality and predictability.
  13. The marketplace is based on prompts our company's developers have used daily for a long time, supplemented by plugins from benchmarked papers and high-quality projects.
  14. ## Key Features
  15. - **Simple to Use** - Easy to install and use without any dependencies. Contains automatically used skills and self-explanatory commands.
  16. - **Token-Efficient** - Carefully crafted prompts and architecture, preferring command-oriented skills with sub-agents over general information skills when possible, to minimize populating context with unnecessary information.
  17. - **Quality-Focused** - Each plugin is focused on meaningfully improving agent results in a specific area.
  18. - **Granular** - Install only the plugins you need. Each plugin loads only its specific agents, commands, and skills, without overlap or redundant skills.
  19. - **Scientifically proven** - Plugins are based on proven techniques and patterns validated by reputable benchmarks and studies.
  20. - **Open-Standards** - Skills are based on [agentskills.io](https://agentskills.io) specification. The [SDD](https://neolab.gitbook.io/cek/plugins/sdd) plugin is based on the **Arc42** specification standard for software development documentation.
  21. ## News
  22. Updates from key releases:
  23. - **v3.1.0:** Improved [Spec-Driven Development plugin](https://neolab.gitbook.io/cek/plugins/sdd) generated code quality by embedding DDD/SOLID rules in the developer agent and adding a dedicated code-reviewer agent that applies functional and OOP best-practices rules together with Muda waste analysis to reduce code complexity and duplication.
  24. - **v3.0.0:** Added support for AMP and Hermes agents. [Tech Stack plugin](https://neolab.gitbook.io/cek/plugins/tech-stack) now automatically injects typescript best practices when agent reads or writes TypeScript files.
  25. - **v2.2.0:** [Subagent-Driven Development plugin](https://neolab.gitbook.io/cek/plugins/sadd) now works as a distilled version of [SDD plugin](https://neolab.gitbook.io/cek/plugins/sdd) using meta-judge and judge sub-agents for specification generation on the fly and in parallel to implementation. [DDD plugin](https://neolab.gitbook.io/cek/plugins/ddd) now includes Clean Architecture, DDD, SOLID, Functional Programming, and other pattern examples as rules that are automatically added to the context during code writing.
  26. - **v2.1.0:** [Spec-Driven Development plugin](https://neolab.gitbook.io/cek/plugins/sdd) agents include high-level code quality guidelines from [DDD plugin](https://neolab.gitbook.io/cek/plugins/ddd).
  27. - **v2.0.0:** [Spec-Driven Development plugin](https://neolab.gitbook.io/cek/plugins/sdd) was rewritten from scratch. It is now able to produce working code in 99% of cases on real-life production projects!
  28. ## Quick Start
  29. ### Step 1: Install Marketplace and Plugins
  30. <details>
  31. <summary>Claude Code</summary>
  32. Open Claude Code and add the Context Engineering Kit marketplace:
  33. ```bash
  34. /plugin marketplace add NeoLabHQ/context-engineering-kit
  35. ```
  36. This makes all plugins available for installation, but does not load any agents or skills into your context.
  37. Install any plugin — for example, reflexion:
  38. ```bash
  39. /plugin install reflexion@NeoLabHQ/context-engineering-kit
  40. ```
  41. Each installed plugin loads only its specific agents, commands, and skills into Claude's context.
  42. </details>
  43. <details>
  44. <summary>Gemini CLI</summary>
  45. Install the extension directly from the repository:
  46. ```bash
  47. gemini extensions install https://github.com/NeoLabHQ/context-engineering-kit
  48. ```
  49. **Note:** This installs every plugin's skills and agents as a single bundle — there's no per-plugin selection like Claude Code's. Unfortunately, Gemini CLI does not support per-plugin selection. But you can delete skills and agents that you don't need, after installation.
  50. </details>
  51. <details>
  52. <summary>Antigravity CLI</summary>
  53. Install the plugin directly from the repository's `antigravity/` folder — Gemini CLI is not required:
  54. ```bash
  55. agy plugin install https://github.com/NeoLabHQ/context-engineering-kit/antigravity
  56. ```
  57. **Note:** This installs every plugin's skills and agents as a single bundle — there's no per-plugin selection like Claude Code's. Unfortunately, Antigravity CLI does not support per-plugin selection. But you can delete skills and agents that you don't need, after installation.
  58. </details>
  59. <details>
  60. <summary>Cursor, Codex, OpenCode and others</summary>
  61. Run the [vercel-labs/skills](https://github.com/vercel-labs/skills) command in your terminal:
  62. ```bash
  63. npx skills add NeoLabHQ/context-engineering-kit
  64. ```
  65. You can pick which skills to install.
  66. **Note:** Each provider uses its own agent format and `npx skills` does not support subagents, so this installation method won't provide the full experience.
  67. </details>
  68. <details>
  69. <summary>Alternative installation methods</summary>
  70. You can use [OpenSkills](https://github.com/numman-ali/openskills) to install skills by running the following commands:
  71. ```bash
  72. npx openskills install NeoLabHQ/context-engineering-kit
  73. npx openskills sync
  74. ```
  75. </details>
  76. ### Step 2: Use Plugin
  77. ```bash
  78. > claude "implement user authentication"
  79. # Claude implements user authentication, then you can ask it to reflect on implementation
  80. > /reflect
  81. # It analyses results and suggests improvements
  82. # If issues are obvious, it will fix them immediately
  83. # If they are minor, it will suggest improvements that you can respond to
  84. > fix the issues
  85. # If you would like to prevent issues found during reflection from appearing again,
  86. # ask Claude to extract resolution strategies and save the insights to project memory
  87. > /memorize
  88. ```
  89. Alternatively, you can use the `reflect` word in the initial prompt:
  90. ```bash
  91. > claude "implement user authentication, then reflect"
  92. # Claude implements user authentication,
  93. # then hook automatically runs /reflect
  94. ```
  95. In order to use this hook, you need to have `bun` installed. However, it is not required for the overall command.
  96. ## Documentation
  97. You can find the complete Context Engineering Kit documentation [here](https://neolab.gitbook.io/cek).
  98. However, the main plugins we recommend starting with are [Subagent-Driven Development](https://neolab.gitbook.io/cek/plugins/sadd) and [Spec-Driven Development](https://neolab.gitbook.io/cek/plugins/sdd).
  99. ### Agent Reliability Engineering
  100. The three plugins in this marketplace are designed to improve how accurately and consistently the agent follows provided instructions and to reduce hallucinations and bias toward incorrect solutions. They are not competitors but rather complementary to each other, because they allow you to balance reliability vs. token cost. Here is a high-level comparison of different agent usage approaches and the probability of receiving results that are fully accurate and include zero hallucinations, based on task complexity:
  101. <table>
  102. <thead>
  103. <tr>
  104. <th rowspan="2">Approach</th>
  105. <th colspan="4">Probability of receiving fully accurate results for the following number of changed files (p)</th>
  106. <th rowspan="2">Tokens Overhead</th>
  107. <th rowspan="2">What does this mean in practice</th>
  108. </tr>
  109. <tr>
  110. <th>1-3</th>
  111. <th>4-10</th>
  112. <th>10-20</th>
  113. <th>20+</th>
  114. </tr>
  115. </thead>
  116. <tbody>
  117. <tr>
  118. <td>One-shot prompt</td>
  119. <td>60%-80%</td>
  120. <td>30%-50%</td>
  121. <td>5%-30%</td>
  122. <td>1%-20%</td>
  123. <td>0</td>
  124. <td>Accuracy depends on model, but with context growth LLM quality degrades exponentially</td>
  125. </tr>
  126. <tr>
  127. <td><a href="https://neolab.gitbook.io/cek/plugins/reflexion/reflect">/reflect</a></td>
  128. <td>68%-91%</td>
  129. <td>49%-71%</td>
  130. <td>13%-41%</td>
  131. <td>1%-30%</td>
  132. <td>1k-3k</td>
  133. <td>Agent finds and fixes missed requirements on its own</td>
  134. </tr>
  135. <tr>
  136. <td><a href="https://neolab.gitbook.io/cek/plugins/reflexion/reflect">/reflect</a> + <a href="https://neolab.gitbook.io/cek/plugins/reflexion/memorize">/memorize</a></td>
  137. <td>79%-87%</td>
  138. <td>60%-79%</td>
  139. <td>34%-42%</td>
  140. <td>5%-30%</td>
  141. <td>2k-5k</td>
  142. <td>Agent extracts repeatable mistakes and avoids them during new tasks</td>
  143. </tr>
  144. <tr>
  145. <td><a href="https://neolab.gitbook.io/cek/plugins/sadd/do-and-judge">/do-and-judge</a></td>
  146. <td>90%</td>
  147. <td>83%</td>
  148. <td>60%</td>
  149. <td>30%</td>
  150. <td>1.5x-3x</td>
  151. <td>Mitigates context rot, bias, hallucinations and missed requirements using Judge sub-agent</td>
  152. </tr>
  153. <tr>
  154. <td><a href="https://neolab.gitbook.io/cek/plugins/sadd/do-in-steps">/do-in-steps</a></td>
  155. <td>92%</td>
  156. <td>90%</td>
  157. <td>71%</td>
  158. <td>50%</td>
  159. <td>3x-5x</td>
  160. <td>Resolves all issues similar to /do-and-judge, but separately per file group</td>
  161. </tr>
  162. <tr>
  163. <td><a href="https://neolab.gitbook.io/cek/plugins/sdd">/plan-task + /implement-task</a></td>
  164. <td>94%</td>
  165. <td>93%</td>
  166. <td>85%</td>
  167. <td>70%</td>
  168. <td>5x-20x</td>
  169. <td>Performs the /do-in-steps flow, but the specification mitigates issues caused by inconsistent architecture and codebase size</td>
  170. </tr>
  171. <tr>
  172. <td><a href="https://neolab.gitbook.io/cek/plugins/sdd/brainstorm">/brainstorm</a> + <a href="https://neolab.gitbook.io/cek/plugins/sdd/plan-task">/plan-task</a> + <a href="https://neolab.gitbook.io/cek/plugins/sdd/implement-task">/implement-task</a></td>
  173. <td>95%</td>
  174. <td>95%</td>
  175. <td>90%</td>
  176. <td>80%</td>
  177. <td>5x-20x</td>
  178. <td>Brainstorming decreases the number of incorrect decisions and missed requirements</td>
  179. </tr>
  180. <tr>
  181. <td><a href="https://neolab.gitbook.io/cek/plugins/sdd/plan-task">/plan-task</a> + human review + <a href="https://neolab.gitbook.io/cek/plugins/sdd/implement-task">/implement-task</a></td>
  182. <td>99%</td>
  183. <td>99%</td>
  184. <td>99%</td>
  185. <td>95%</td>
  186. <td>5x-35x</td>
  187. <td>Human review mitigates misunderstanding of requirements by LLM</td>
  188. </tr>
  189. </tbody>
  190. </table>
  191. > Reliability metrics are based on more than year of real development usage on production projects.
  192. ## Plugins List
  193. To view all available plugins:
  194. ```bash
  195. /plugin
  196. ```
  197. - [Reflexion](https://neolab.gitbook.io/cek/plugins/reflexion) - Feedback and refinement loops to improve output quality.
  198. - [Spec-Driven Development](https://neolab.gitbook.io/cek/plugins/sdd) - Commands for specification-driven development, based on Continuous Learning + LLM-as-Judge + Agent Swarm. Achieves **development as compilation** through reliable code generation.
  199. - [Review](https://neolab.gitbook.io/cek/plugins/review) - Open-source and higher quality version of CodeRabbit. Includes code and PR review commands and skills using multiple specialized agents with impact/confidence filtering. [Free Github Actions integration available](https://neolab.gitbook.io/cek/guides/ci-integration)
  200. - [Git](https://neolab.gitbook.io/cek/plugins/git) - Commands for commit and PR creation.
  201. - [Test-Driven Development](https://neolab.gitbook.io/cek/plugins/tdd) - Commands for test-driven development and common anti-patterns, plus skills for testing using subagents.
  202. - [Subagent-Driven Development](https://neolab.gitbook.io/cek/plugins/sadd) - Skills for subagent-driven development, which dispatches a fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates.
  203. - [Domain-Driven Development](https://neolab.gitbook.io/cek/plugins/ddd) - Commands to update CLAUDE.md with best practices for domain-driven development, focused on code quality, and includes Clean Architecture, SOLID principles, and other design patterns.
  204. - [FPF - First Principles Framework](https://neolab.gitbook.io/cek/plugins/fpf) - Structured reasoning using ADI cycle (Abduction-Deduction-Induction) with knowledge layer progression. Uses workflow command pattern with fpf-agent for hypothesis generation, verification, and auditable decision-making.
  205. - [Kaizen](https://neolab.gitbook.io/cek/plugins/kaizen) - Inspired by Japanese continuous improvement philosophy, Agile and Lean development practices. Commands for analysis of root causes of issues and problems, including 5 Whys, Cause and Effect Analysis, and other techniques.
  206. - [Customaize Agent](https://neolab.gitbook.io/cek/plugins/customaize-agent) - Commands and skills for writing and refining commands, hooks, and skills for Claude Code. Includes Anthropic Best Practices and [Agent Persuasion Principles](https://arxiv.org/abs/2508.00614) that can be useful for sub-agent workflows.
  207. - [Docs](https://neolab.gitbook.io/cek/plugins/docs) - Commands for analyzing projects, writing and refining documentation.
  208. - [Tech Stack](https://neolab.gitbook.io/cek/plugins/tech-stack) - Rules for language-specific best practices, automatically applied when working on matching file types.
  209. - [MCP](https://neolab.gitbook.io/cek/plugins/mcp) - Commands for setting up well-known MCP server integrations when needed and updating the CLAUDE.md file with requirements to use MCP servers in the current project.
  210. ## Works Great With
  211. We developed the following projects to speed up development further and improve code quality:
  212. - [Agent Sandbox](https://github.com/NeoLabHQ/sandbox) - Development sandbox image for agents, based on the official devcontainers images from Microsoft. Works out of the box with most languages and agents.
  213. - [Agent Eslint Config](https://github.com/NeoLabHQ/agent-eslint-config) - An overly opinionated ESLint config for AI agents. Forces them to write low-complexity, highly readable code. Includes SonarJS, Unicorn, and 100+ rules focused on security and cognitive complexity.
  214. Both are tested and combine well with the [SADD](https://neolab.gitbook.io/cek/plugins/sadd)/[SDD](https://neolab.gitbook.io/cek/plugins/sdd) plugins, but also work great independently of Context Engineering Kit.
  215. ## Stay ahead
  216. Star Context Engineering Kit on GitHub to support its development and get notified about new features and updates.
  217. <img src="docs/assets/context-engineering-kit-like.gif" alt="Star Context Engineering Kit on GitHub" />
  218. ### [Reflexion](https://neolab.gitbook.io/cek/plugins/reflexion)
  219. Collection of commands that force the LLM to reflect on the previous response and output. Includes **automatic reflection hooks** that trigger when you include "reflect" in your prompt.
  220. **How to install**
  221. ```bash
  222. /plugin install reflexion@NeoLabHQ/context-engineering-kit
  223. ```
  224. **Commands**
  225. - [/reflect](https://neolab.gitbook.io/cek/plugins/reflexion/reflect) - Reflect on the previous response and output based on the self-refinement framework for iterative improvement with complexity triage and verification
  226. - [/memorize](https://neolab.gitbook.io/cek/plugins/reflexion/memorize) - Curate insights from reflections and critiques into CLAUDE.md using Agentic Context Engineering
  227. - [/critique](https://neolab.gitbook.io/cek/plugins/reflexion/critique) - Comprehensive multi-perspective review using specialized judges with debate and consensus building
  228. **Hooks**
  229. - **Automatic Reflection Hook** - Triggers `/reflect` automatically when "reflect" appears in your prompt
  230. **Theoretical Foundation**
  231. The plugin is based on papers like [Self-Refine](https://arxiv.org/abs/2303.17651) and [Reflexion](https://arxiv.org/abs/2303.11366). These techniques improve the output of large language models by introducing feedback and refinement loops.
  232. They are proven to **increase output quality by 8–21%** based on both automatic metrics and human preferences across seven diverse tasks, including dialogue generation, coding, and mathematical reasoning, when compared to standard one-step model outputs.
  233. On top of that, the plugin is based on the [Agentic Context Engineering](https://arxiv.org/abs/2510.04618) paper, which uses memory updates after reflection and **consistently outperforms strong baselines by 10.6%** in agent applications.
  234. ### [Review](https://neolab.gitbook.io/cek/plugins/review)
  235. Comprehensive code and PR review commands that use multiple specialized agents for thorough code quality evaluation with impact/confidence filtering.
  236. **How to install**
  237. ```bash
  238. /plugin install review@NeoLabHQ/context-engineering-kit
  239. ```
  240. **Commands**
  241. - [/review-local-changes](https://neolab.gitbook.io/cek/plugins/review/review-local-changes) - Comprehensive review of local uncommitted changes using specialized agents with code improvement suggestions
  242. - [/review-pr](https://neolab.gitbook.io/cek/plugins/review/review-pr) - Comprehensive pull request review using specialized agents
  243. - [/traiage-review](https://neolab.gitbook.io/cek/plugins/review/traiage-review) - Pick the top most important files from huge changeset for human reviewer, to decrease amount of files that need to review before approving it.
  244. **Agents**
  245. This plugin uses multiple specialized agents for comprehensive code quality analysis:
  246. - **bug-hunter** - Identifies potential bugs, edge cases, and error-prone patterns
  247. - **code-quality-reviewer** - Evaluates code structure, readability, and maintainability
  248. - **contracts-reviewer** - Reviews interfaces, API contracts, and data models
  249. - **historical-context-reviewer** - Analyzes changes in relation to codebase history and patterns
  250. - **security-auditor** - Identifies security vulnerabilities and potential attack vectors
  251. - **test-coverage-reviewer** - Evaluates test coverage and suggests missing test cases
  252. The `traiage-review` skill additionally uses four change-triage agents:
  253. - **change-story-agent
  254. - **change-impact-agent**
  255. - **change-failure-agent**
  256. - **change-expectation-agent**
  257. You can use this plugin to review code in GitHub Actions; to do so, follow [this guide](https://neolab.gitbook.io/cek/guides/ci-integration).
  258. ### [Git](https://neolab.gitbook.io/cek/plugins/git)
  259. Commands and skills for streamlined Git operations including commits, pull request creation, and advanced workflow patterns.
  260. **How to install**
  261. ```bash
  262. /plugin install git@NeoLabHQ/context-engineering-kit
  263. ```
  264. **Commands**
  265. - [/commit](https://neolab.gitbook.io/cek/plugins/git/commit) - Create well-formatted commits with conventional commit messages and emoji
  266. - [/create-pr](https://neolab.gitbook.io/cek/plugins/git/create-pr) - Create pull requests using GitHub CLI with proper templates and formatting
  267. - [/analyze-issue](https://neolab.gitbook.io/cek/plugins/git/analyze-issue) - Analyze a GitHub issue and create a detailed technical specification
  268. - [/load-issues](https://neolab.gitbook.io/cek/plugins/git/load-issues) - Load all open issues from GitHub and save them as markdown files
  269. - [/load-pr-comments](https://neolab.gitbook.io/cek/plugins/git/load-pr-comments) - Load open/unresolved PR review comments and group them as tasks for parallel agents to fix.
  270. - [/worktree](https://neolab.gitbook.io/cek/plugins/git/git-worktrees) - Create, compare, and merge git worktrees for parallel development with automatic dependency installation
  271. **Skills**
  272. - [git-notes](https://neolab.gitbook.io/cek/plugins/git/git-notes) - Skill for using git notes to add metadata to commits without changing history.
  273. - [resolve-fixed-pr-comments](https://neolab.gitbook.io/cek/plugins/git/resolve-fixed-pr-comments) - Verify what PR review comments have been addressed and resolve that are genuinely fixed or no longer relevant.
  274. ### [Test-Driven Development](https://neolab.gitbook.io/cek/plugins/tdd)
  275. Commands and skills for test-driven development with anti-pattern detection.
  276. **How to install**
  277. ```bash
  278. /plugin install tdd@NeoLabHQ/context-engineering-kit
  279. ```
  280. **Commands**
  281. - [/write-tests](https://neolab.gitbook.io/cek/plugins/tdd/write-tests) - Systematically add test coverage for local code changes using specialized review and development agents
  282. - [/fix-tests](https://neolab.gitbook.io/cek/plugins/tdd/fix-tests) - Fix failing tests after business logic changes or refactoring using orchestrated agents
  283. **Skills**
  284. - [test-driven-development](https://neolab.gitbook.io/cek/plugins/tdd/test-driven-development) - Introduces TDD methodology, best practices, and skills for testing using subagents
  285. - [design-testing-strategy](https://neolab.gitbook.io/cek/plugins/tdd/design-testing-strategy) - Manual guide to design a plan for the best way to cover a given artifact with tests while minimizing effort and maximizing coverage.
  286. - [test-coverage](https://neolab.gitbook.io/cek/plugins/tdd/test-coverage) - Manual for choosing, applying, different types of coverage analysis (structural, mutation, requirements, API/integration) on an existing test suite.
  287. ### [Subagent-Driven Development](https://neolab.gitbook.io/cek/plugins/sadd)
  288. Execution framework for competitive generation, multi-agent evaluation, and subagent-driven development with quality gates.
  289. **How to install**
  290. ```bash
  291. /plugin install sadd@NeoLabHQ/context-engineering-kit
  292. ```
  293. **Commands**
  294. - [/launch-sub-agent](https://neolab.gitbook.io/cek/plugins/sadd/launch-sub-agent) - Launch focused sub-agents with intelligent model selection, Zero-shot CoT reasoning, and self-critique verification
  295. - [/do-and-judge](https://neolab.gitbook.io/cek/plugins/sadd/do-and-judge) - Execute a single task with implementation sub-agent, independent judge verification, and automatic retry loop until passing
  296. - [/do-in-parallel](https://neolab.gitbook.io/cek/plugins/sadd/do-in-parallel) - Execute the same task across multiple independent targets in parallel with context isolation
  297. - [/do-in-steps](https://neolab.gitbook.io/cek/plugins/sadd/do-in-steps) - Execute complex tasks through sequential sub-agent orchestration with automatic decomposition and context passing
  298. - [/do-competitively](https://neolab.gitbook.io/cek/plugins/sadd/do-competitively) - Execute tasks through competitive generation, multi-judge evaluation, and evidence-based synthesis to produce superior results
  299. - [/tree-of-thoughts](https://neolab.gitbook.io/cek/plugins/sadd/tree-of-thoughts) - Execute complex reasoning through systematic exploration of solution space, pruning unpromising branches, and synthesizing the best solution
  300. - [/judge-with-debate](https://neolab.gitbook.io/cek/plugins/sadd/judge-with-debate) - Evaluate solutions through iterative multi-judge debate with consensus building or disagreement reporting
  301. - [/judge](https://neolab.gitbook.io/cek/plugins/sadd/judge) - Evaluate completed work using LLM-as-Judge with structured rubrics and evidence-based scoring
  302. **Skills**
  303. - [subagent-driven-development](https://neolab.gitbook.io/cek/plugins/sadd/subagent-driven-development) - Dispatches a fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
  304. - [multi-agent-patterns](https://neolab.gitbook.io/cek/plugins/sadd/multi-agent-patterns) - Design multi-agent architectures (supervisor, peer-to-peer, hierarchical) for complex tasks exceeding single-agent context limits
  305. ### [Spec-Driven Development](https://neolab.gitbook.io/cek/plugins/sdd)
  306. Comprehensive specification-driven development workflow plugin that transforms prompts into production-ready implementations through structured planning, architecture design, and quality-gated execution.
  307. This plugin is designed to consistently produce working code. It was tested on real-life production projects by our team, and in 100% of cases, it generated working code aligned with the initial prompt. If you find a use case it cannot handle, please report it as an issue.
  308. #### Key Features
  309. - **Development as compilation** — The plugin works like a "compilation" or "nightly build" for your development process: `task specs → run /implement-task → working code`. After writing your prompt, you can launch the plugin and expect a working result when you come back. The time it takes depends on task complexity — simple tasks may finish in 30 minutes, while complex ones can take a few days.
  310. - **Benchmark-level quality in real life** — Model benchmarks improve with each release, yet real-world results usually stay the same. That's because benchmarks reflect the best possible output a model can achieve, whereas in practice LLMs tend to drift toward sub-optimal solutions that can be wrong or non-functional. This plugin uses a variety of patterns to keep the model working at its peak performance.
  311. - **Customizable** — Balance result quality and process speed by adjusting command parameters. Learn more in the [Customization](./customization.md) section.
  312. - **Time-efficient for developers** — The overall process is designed to minimize developer time and reduce the number of interactions, while still producing results better than what a model can generate from scratch. However, overall quality is highly proportional to the time you invest in iterating and refining the specification.
  313. - **Industry-standard** — The plugin's specification template is based on the arc42 standard, adjusted for LLM capabilities. Arc42 is a widely adopted, high-quality standard for software development documentation used by many companies and organizations.
  314. - **Works best in complex or large codebases** — While most other frameworks work best for new projects and greenfield development, this plugin is designed to perform better the more existing code and well-structured architecture you have. At each planning phase, it includes a **codebase impact analysis** step that evaluates which files may be affected and which patterns to follow to achieve the desired result.
  315. - **Simple** — This plugin avoids unnecessary complexity and mainly uses just 3 commands, offloading process complexity to the model via multi-agent orchestration. `/implement-task` is a single command that produces working code from a task specification. To create that specification, you run `/sdd:add-task` and `/plan-task`, which analyze your prompt and iteratively refine the specification until it meets the required quality.
  316. #### Quick Start
  317. ```bash
  318. /plugin install sdd@NeoLabHQ/context-engineering-kit
  319. ```
  320. Then run the following commands:
  321. ```bash
  322. # create .specs/tasks/draft/design-auth-middleware.feature.md file with initial prompt
  323. /add-task "Design and implement authentication middleware with JWT support"
  324. # write detailed specification for the task
  325. /plan-task .specs/tasks/draft/design-auth-middleware.feature.md
  326. # will move task to .specs/tasks/todo/ folder
  327. ```
  328. Restart the Claude Code session to clear context and start fresh. Then run the following command:
  329. ```bash
  330. # implement the task
  331. /implement-task @.specs/tasks/todo/design-auth-middleware.feature.md
  332. # produces working implementation and moves the task to .specs/tasks/done/ folder
  333. ```
  334. - [Detailed guide](https://neolab.gitbook.io/cek/guides/spec-driven-development)
  335. - [Usage Examples](https://neolab.gitbook.io/cek/plugins/sdd/usage-examples)
  336. **Commands**
  337. - [/add-task](https://neolab.gitbook.io/cek/plugins/sdd/add-task) - Create task template file with initial prompt
  338. - [/plan-task](https://neolab.gitbook.io/cek/plugins/sdd/plan) - Analyze prompt, generate required skills and refine task specification
  339. - [/implement-task](https://neolab.gitbook.io/cek/plugins/sdd/implement) - Produce a working implementation of the task and verify it
  340. Additional commands useful before creating a task:
  341. - [/create-ideas](https://neolab.gitbook.io/cek/plugins/sdd/create-ideas) - Generate diverse ideas on a given topic using creative sampling techniques
  342. - [/brainstorm](https://neolab.gitbook.io/cek/plugins/sdd/brainstorm) - Refine vague ideas into fully-formed designs through collaborative dialogue
  343. **Agents**
  344. | Agent | Description | Used By |
  345. |-------|-------------|---------|
  346. | `researcher` | Technology research, dependency analysis, best practices; creates a reusable skill file | `/plan-task` (Phase 2a) |
  347. | `code-explorer` | Codebase analysis, pattern identification, architecture mapping | `/plan-task` (Phase 2b) |
  348. | `business-analyst` | Requirements discovery, scope and user scenarios, and the whole `## Acceptance Criteria` section — checklist, regular checks, rubric, score definitions, test strategy and definition of done | `/plan-task` (Phase 2c) |
  349. | `software-architect` | Architecture design, component design, solution strategy and expected changes | `/plan-task` (Phase 3) |
  350. | `tech-lead` | Decomposition into per-step sub-task files, dependency mapping, parallelization, risk analysis, and grouping steps into independently verifiable phases with a reviewer model each | `/plan-task` (Phase 4) |
  351. | `developer` | Implements exactly one step, from its own sub-task file, and leaves the tree building and green | `/implement-task` (per step) |
  352. | `code-reviewer` | Reviews a whole implementation phase against the acceptance criteria that phase lists as due, plus code quality, Muda waste analysis and test coverage | `/implement-task` (end of each phase) |
  353. | `tech-writer` | Technical documentation writing, API guides, usage examples, architecture updates | `/implement-task` |
  354. #### Patterns
  355. Key patterns implemented in this plugin:
  356. - **Structured reasoning templates** — includes Zero-shot and Few-shot Chain of Thought, Tree of Thoughts, Problem Decomposition, and Self-Critique. Each is tailored to a specific agent and task, enabling sufficiently detailed decomposition so that isolated sub-agents can implement each step independently.
  357. - **Multi-agent orchestration for context management** — Context isolation of independent agents prevents the context rot problem, essentially keeping LLMs at optimal performance at each step of the process. The main agent acts as an orchestrator that launches sub-agents and controls their work.
  358. - **Quality gates based on LLM-as-Judge** — Evaluate the quality of each planning and implementation step using evidence-based scoring and predefined verification rubrics. This fully eliminates cases where an agent produces non-working or incorrect solutions.
  359. - **Continuous learning** — Builds skills that the agent needs to implement a specific task, which it would otherwise not be able to perform from scratch.
  360. - **Spec-driven development pattern** — Based on the arc42 specification standard, adjusted for LLM capabilities, to eliminate parts of the specification that add no value to implementation quality or that could degrade it.
  361. - **MAKER** — An agent reliability pattern introduced in [Solving a Million-Step LLM Task with Zero Errors](https://arxiv.org/abs/2511.09030). It removes agent mistakes caused by accumulated context and hallucinations by utilizing clean-state agent launches and filesystem-based memory storage.
  362. #### Vibe Coding vs. Specification-Driven Development
  363. This plugin is not a "vibe coding" solution, but out of the box, it works like one. By default, it is designed to work from a single prompt through to the end of the task, making reasonable assumptions and evidence-based decisions instead of constantly asking for clarification. This is because developer time is more valuable than model time. As a result, the plugin is designed to allow the developer to decide how much time the task is worth. The plugin will always produce working results, but quality will be sub-optimal if no human feedback is provided.
  364. To improve quality, after generating a specification you can correct it or leave comments using `//`, then run the `/plan-task` command again with the `--refine` flag. You can also verify each planning and implementation phase by adding the `--human-in-the-loop` flag. According to most known research, human feedback is the most effective way to improve results.
  365. Our tests showed that even when the initially generated specification was incorrect due to lack of information or task complexity, the agent was still able to self-correct until it reached a working solution. However, it usually takes much longer and results in the agent spending time on wrong paths and stopping more frequently. To avoid this, we strongly advise decomposing tasks into smaller separate tasks with dependencies and reviewing the specification for each one independently. You can add dependencies between tasks as arguments to the `/add-task` command, and the agent will link them together by adding a `depends_on` section to the task file frontmatter.
  366. Even if you don't want to spend much time on this process, you can still use the plugin for complex tasks without decomposition or human verification — but you will likely need tools like ralph-loop to keep the agent running for longer.
  367. Learn more about available customization options in [Customization](https://neolab.gitbook.io/cek/plugins/sdd/customization).
  368. ### [Domain-Driven Development](https://neolab.gitbook.io/cek/plugins/ddd)
  369. Code quality framework with rules for Clean Architecture, SOLID principles, and Domain-Driven Design patterns.
  370. **How to install**
  371. ```bash
  372. /plugin install ddd@NeoLabHQ/context-engineering-kit
  373. ```
  374. **Rules**
  375. - 15 composable rules covering Clean Architecture, SOLID principles, Command-Query Separation, Functional Core/Imperative Shell, Explicit Control Flow, Domain-Specific Naming, and more. See [rules reference](https://neolab.gitbook.io/cek/plugins/ddd/rules)
  376. ### [FPF - First Principles Framework](https://neolab.gitbook.io/cek/plugins/fpf)
  377. A structured reasoning plugin that implements the **[First Principles Framework (FPF)](https://github.com/ailev/FPF)** by Anatoly Levenchuk — a methodology for rigorous, auditable reasoning. The killer feature is turning the black box of AI reasoning into a transparent, evidence-backed audit trail. The plugin makes AI decision-making transparent and auditable. Instead of jumping to solutions, FPF enforces generating competing hypotheses, checking them logically, testing against evidence, then letting developers choose.
  378. Key principles:
  379. - **Transparent reasoning** - Full audit trail from hypothesis to decision
  380. - **Hypothesis-driven** - Generate 3-5 competing alternatives before evaluating
  381. - **Evidence-based** - Computed trust scores, not estimates
  382. - **Human-in-the-loop** - AI generates options; humans decide (Transformer Mandate)
  383. The core cycle follows three modes of inference:
  384. 1. **Abduction** — Generate competing hypotheses (don't anchor on the first idea).
  385. 2. **Deduction** — Verify logic and constraints (does the idea make sense?).
  386. 3. **Induction** — Gather evidence through tests or research (does the idea work in reality?).
  387. Then, audit for bias, decide, and document the rationale in a durable record.
  388. > **Warning:** This plugin loads the core FPF specification into context, which is large (~600k tokens). As a result, it is loaded into a subagent with the Sonnet[1m] model. However, such an agent can consume your token limit quickly.
  389. **How to install**
  390. ```bash
  391. /plugin install fpf@NeoLabHQ/context-engineering-kit
  392. ```
  393. #### Usage workflow
  394. ```bash
  395. # Execute complete FPF cycle from hypothesis to decision
  396. /propose-hypotheses What caching strategy should we use?
  397. # The workflow will:
  398. # 1. Initialize context and .fpf/ directory
  399. # 2. Generate competing hypotheses
  400. # 3. Allow you to add your own alternatives
  401. # 4. Verify each against project constraints (parallel)
  402. # 5. Validate with evidence (parallel)
  403. # 6. Compute trust scores (parallel)
  404. # 7. Present comparison for your decision
  405. ```
  406. **Commands**
  407. - [/propose-hypotheses](https://neolab.gitbook.io/cek/plugins/fpf/propose-hypotheses) - Execute complete FPF cycle from hypothesis to decision (main workflow)
  408. - [/status](https://neolab.gitbook.io/cek/plugins/fpf/status) - Show current FPF phase and hypothesis counts
  409. - [/query](https://neolab.gitbook.io/cek/plugins/fpf/query) - Search knowledge base with assurance info
  410. - [/decay](https://neolab.gitbook.io/cek/plugins/fpf/decay) - Manage evidence freshness (refresh/deprecate/waive)
  411. - [/actualize](https://neolab.gitbook.io/cek/plugins/fpf/actualize) - Reconcile knowledge with codebase changes
  412. - [/reset](https://neolab.gitbook.io/cek/plugins/fpf/reset) - Archive session and return to IDLE
  413. **Agent**
  414. - [fpf-agent](https://neolab.gitbook.io/cek/plugins/fpf/fpf-agent) - FPF reasoning specialist for hypothesis generation, verification, validation, and trust calculus using ADI cycle and knowledge layer progression
  415. ### [Kaizen](https://neolab.gitbook.io/cek/plugins/kaizen)
  416. Continuous improvement methodology inspired by Japanese philosophy and Agile practices.
  417. **How to install**
  418. ```bash
  419. /plugin install kaizen@NeoLabHQ/context-engineering-kit
  420. ```
  421. **Commands**
  422. - [/analyse](https://neolab.gitbook.io/cek/plugins/kaizen/analyse) - Auto-selects best Kaizen method (Gemba Walk, Value Stream, or Muda) for target analysis
  423. - [/analyse-problem](https://neolab.gitbook.io/cek/plugins/kaizen/analyse-problem) - Comprehensive A3 one-page problem analysis with root cause and action plan
  424. - [/why](https://neolab.gitbook.io/cek/plugins/kaizen/why) - Iterative Five Whys root cause analysis drilling from symptoms to fundamentals
  425. - [/root-cause-tracing](https://neolab.gitbook.io/cek/plugins/kaizen/root-cause-tracing) - Systematically traces bugs backward through call stack to identify source of invalid data or incorrect behavior
  426. - [/cause-and-effect](https://neolab.gitbook.io/cek/plugins/kaizen/cause-and-effect) - Systematic Fishbone analysis exploring problem causes across six categories
  427. - [/plan-do-check-act](https://neolab.gitbook.io/cek/plugins/kaizen/plan-do-check-act) - Iterative PDCA cycle for systematic experimentation and continuous improvement
  428. **Skills**
  429. - [kaizen](https://neolab.gitbook.io/cek/plugins/kaizen/kaizen) - Continuous improvement methodology with multiple analysis techniques
  430. ### [Customaize Agent](https://neolab.gitbook.io/cek/plugins/customaize-agent)
  431. Commands and skills for creating and refining Claude Code extensions.
  432. **How to install**
  433. ```bash
  434. /plugin install customaize-agent@NeoLabHQ/context-engineering-kit
  435. ```
  436. **Commands**
  437. - [/create-agent](https://neolab.gitbook.io/cek/plugins/customaize-agent/create-agent) - Comprehensive guide for creating Claude Code agents with proper structure, triggering conditions, system prompts, and validation
  438. - [/create-command](https://neolab.gitbook.io/cek/plugins/customaize-agent/create-command) - Interactive assistant for creating new Claude commands with proper structure and patterns
  439. - [/create-workflow-command](https://neolab.gitbook.io/cek/plugins/customaize-agent/create-workflow-command) - Create workflow commands that orchestrate multi-step execution through sub-agents with file-based task prompts
  440. - [/create-skill](https://neolab.gitbook.io/cek/plugins/customaize-agent/create-skill) - Guide for creating effective skills with test-driven approach
  441. - [/create-hook](https://neolab.gitbook.io/cek/plugins/customaize-agent/create-hook) - Create and configure git hooks with intelligent project analysis and automated testing
  442. - [/test-skill](https://neolab.gitbook.io/cek/plugins/customaize-agent/test-skill) - Verify skills work under pressure and resist rationalization using RED-GREEN-REFACTOR cycle
  443. - [/test-prompt](https://neolab.gitbook.io/cek/plugins/customaize-agent/test-prompt) - Test any prompt (commands, hooks, skills, subagent instructions) using RED-GREEN-REFACTOR cycle with subagents
  444. - [/apply-anthropic-skill-best-practices](https://neolab.gitbook.io/cek/plugins/customaize-agent/apply-anthropic-skill-best-practices) - Comprehensive guide for skill development based on Anthropic's official best practices
  445. **Skills**
  446. - [prompt-engineering](https://neolab.gitbook.io/cek/plugins/customaize-agent/prompt-engineering) - Well-known prompt engineering techniques and patterns, includes Anthropic Best Practices and Agent Persuasion Principles
  447. - [context-engineering](https://neolab.gitbook.io/cek/plugins/customaize-agent/context-engineering) - Deep understanding of context mechanics: attention budget, progressive disclosure, lost-in-middle effect, and practical optimization patterns
  448. - [agent-evaluation](https://neolab.gitbook.io/cek/plugins/customaize-agent/agent-evaluation) - Evaluation frameworks for agent systems: LLM-as-Judge, multi-dimensional rubrics, bias mitigation, and the 95% performance finding
  449. ### [Docs](https://neolab.gitbook.io/cek/plugins/docs)
  450. Commands for project analysis and documentation management based on proven writing principles.
  451. **How to install**
  452. ```bash
  453. /plugin install docs@NeoLabHQ/context-engineering-kit
  454. ```
  455. **Commands**
  456. - [/update-docs](https://neolab.gitbook.io/cek/plugins/docs/update-docs) - Update implementation documentation after completing development phases
  457. - [/write-concisely](https://neolab.gitbook.io/cek/plugins/docs/write-concisely) - Apply *The Elements of Style* principles to make documentation clearer and more professional
  458. ### [Tech Stack](https://neolab.gitbook.io/cek/plugins/tech-stack)
  459. Rules for language and framework-specific best practices, automatically applied when the agent works on matching file types.
  460. **How to install**
  461. ```bash
  462. /plugin install tech-stack@NeoLabHQ/context-engineering-kit
  463. ```
  464. **Rules**
  465. - TypeScript Best Practices - Type system guidelines, code style, async patterns, and code quality standards, automatically loaded when the agent reads or writes `.ts` files
  466. ### [MCP](https://neolab.gitbook.io/cek/plugins/mcp)
  467. Commands for integrating Model Context Protocol servers with your project. Each setup command supports configuration at multiple levels:
  468. - **Project level (shared)** - Configuration tracked in git, shared with team via `./CLAUDE.md`
  469. - **Project level (personal)** - Local configuration in `./CLAUDE.local.md`, not tracked in git
  470. - **User level (global)** - Configuration in `~/.claude/CLAUDE.md`, applies to all projects
  471. **How to install**
  472. ```bash
  473. /plugin install mcp@NeoLabHQ/context-engineering-kit
  474. ```
  475. **Commands**
  476. - [/setup-context7-mcp](https://neolab.gitbook.io/cek/plugins/mcp/setup-context7-mcp) - Guide for setting up Context7 MCP server to load documentation for specific technologies
  477. - [/setup-serena-mcp](https://neolab.gitbook.io/cek/plugins/mcp/setup-serena-mcp) - Guide for setting up Serena MCP server for semantic code retrieval and editing capabilities
  478. - [/setup-codemap-cli](https://neolab.gitbook.io/cek/plugins/mcp/setup-codemap-cli) - Guide for setting up Codemap CLI for intelligent codebase visualization and navigation
  479. - [/setup-arxiv-mcp](https://neolab.gitbook.io/cek/plugins/mcp/setup-arxiv-mcp) - Guide for setting up arXiv/Paper Search MCP server via Docker MCP for academic paper search and retrieval from multiple sources
  480. - [/build-mcp](https://neolab.gitbook.io/cek/plugins/mcp/build-mcp) - Guide for creating high-quality MCP servers that enable LLMs to interact with external services
  481. ## Theoretical Foundation
  482. This project is based on research and papers from the following sources:
  483. - [Self-Refine](https://arxiv.org/abs/2303.17651) - Core refinement loop
  484. - [Reflexion](https://arxiv.org/abs/2303.11366) - Memory integration
  485. - [Constitutional AI](https://arxiv.org/abs/2212.08073) - Principle-based critique
  486. - [LLM-as-a-Judge](https://arxiv.org/abs/2306.05685) - Evaluation patterns
  487. - [Multi-Agent Debate](https://arxiv.org/abs/2305.14325) - Multiple perspectives
  488. - [Agentic Context Engineering](https://arxiv.org/abs/2510.04618) - Memory curation
  489. - [Chain-of-Verification](https://arxiv.org/abs/2309.11495) - Hallucination reduction
  490. - [Tree of Thoughts](https://arxiv.org/abs/2305.10601) - Structured exploration
  491. - [Process Reward Models](https://arxiv.org/abs/2305.20050) - Step-by-step evaluation
  492. - [Verbalized Sampling](https://arxiv.org/abs/2510.01171) - Diverse idea generation with 2-3x improvement
  493. - [Process Reward Models](https://arxiv.org/abs/2305.20050) - Step verification
  494. - [Chain of Thought Prompting](https://arxiv.org/abs/2201.11903) - Step-by-step reasoning
  495. - [Inference-Time Scaling of Verification](https://arxiv.org/abs/2601.15808) - Rubric-guided verification
  496. More details about the theoretical foundation can be found on the [resources](https://neolab.gitbook.io/cek/resources) page.
plugins/reflexion/hooks/src/index.ts · Bundled script · 155 lines · 1 finding marked
  1. #!/usr/bin/env bun
  2. import type {
  3. NotificationHandler,
  4. PostToolUseHandler,
  5. PreCompactHandler,
  6. PreToolUseHandler,
  7. SessionStartHandler,
  8. SubagentStopHandler,
  9. UserPromptSubmitHandler,
  10. } from './lib'
  11. import {runHook, log} from './lib'
  12. import { stop } from './onStopHandler'
  13. // SessionStart handler - called when a new Claude session starts
  14. const sessionStart: SessionStartHandler = async (payload) => {
  15. // Example: Log session start with source
  16. log(`🚀 New session started from: ${payload.source}`)
  17. log(`📍 Session ID: ${payload.session_id}`)
  18. // Example: Load user preferences or configuration
  19. // const userConfig = await loadUserPreferences()
  20. // Example: Set up session-specific resources
  21. // await initializeSessionResources(payload.session_id)
  22. // Example: Apply different behavior based on session source
  23. if (payload.source === 'vscode') {
  24. log('👨‍💻 VS Code session detected - enabling IDE-specific features')
  25. } else if (payload.source === 'web') {
  26. log('🌐 Web session detected')
  27. }
  28. // Add your custom session initialization logic here
  29. return {} // Empty object means continue normally
  30. }
  31. // PreToolUse handler - called before Claude uses any tool
  32. // This handler can block tool execution by returning a deny decision
  33. const preToolUse: PreToolUseHandler = async (payload) => {
  34. // Example: Log when Claude is about to edit files
  35. if (payload.tool_name === 'Edit' && payload.tool_input) {
  36. const {file_path} = payload.tool_input as {file_path: string}
  37. log(`📝 Claude is editing: ${file_path}`)
  38. }
  39. // Example: Track bash commands
  40. if (payload.tool_name === 'Bash' && payload.tool_input && 'command' in payload.tool_input) {
  41. const command = (payload.tool_input as {command: string}).command
  42. log(`🚀 Running command: ${command}`)
  43. // Block dangerous commands
  44. if (command.includes('rm -rf /') || command.includes('rm -rf ~')) {
    • Note: Quoted as data in code: Runs `rm -rf` against a root or home-directory path
    • Line 56 on GitHub
  45. console.error('❌ Dangerous command detected! Blocking execution.')
  46. return {
  47. permissionDecision: 'deny',
  48. permissionDecisionReason: `Dangerous command detected: ${command}`,
  49. }
  50. }
  51. }
  52. // Add your custom logic here!
  53. // You have full TypeScript support and can use any npm packages
  54. return {} // Empty object means continue with default behavior
  55. }
  56. // PostToolUse handler - called after Claude uses a tool
  57. const postToolUse: PostToolUseHandler = async (payload) => {
  58. // Example: React to successful file writes
  59. if (payload.tool_name === 'Write' && payload.tool_response) {
  60. log(`✅ File written successfully!`)
  61. }
  62. // Add your custom post-processing logic here
  63. return {} // Return empty object to continue normally
  64. }
  65. // Notification handler - receive Claude's notifications
  66. const notification: NotificationHandler = async (payload) => {
  67. // Example: Log Claude's progress
  68. log(`🔔 ${payload.message}`)
  69. return {} // Return empty object to continue normally
  70. }
  71. // SubagentStop handler - called when a Claude subagent (Task tool) stops
  72. const subagentStop: SubagentStopHandler = async (payload) => {
  73. // Example: Log subagent completion
  74. log(`🤖 Subagent task completed`)
  75. // Add your custom subagent cleanup logic here
  76. // Note: Be careful with stop_hook_active to avoid infinite loops
  77. if (payload.stop_hook_active) {
  78. log('⚠️ Stop hook is already active, skipping additional processing')
  79. }
  80. return {} // Return empty object to continue normally
  81. }
  82. // UserPromptSubmit handler - called when the user submits a prompt
  83. const userPromptSubmit: UserPromptSubmitHandler = async (payload) => {
  84. // Example: Log user prompts
  85. log(`💬 User prompt: ${payload.prompt}`)
  86. // By default continue normally and just record user prompt
  87. return {}
  88. }
  89. // PreCompact handler - called before Claude compacts the conversation
  90. const preCompact: PreCompactHandler = async (payload) => {
  91. // Example: Log compact events
  92. log(`🗜️ Compact triggered: ${payload.trigger}`)
  93. // Example: Block automatic compaction during critical operations
  94. if (payload.trigger === 'auto') {
  95. // You could check if critical operations are in progress
  96. // For now, we'll allow all compactions
  97. log('📋 Allowing automatic compaction')
  98. }
  99. // Add your custom compaction logic here
  100. return {} // Empty object means allow compaction
  101. }
  102. const main = (): void => {
  103. // Run the hook with our handlers
  104. runHook({
  105. SessionStart: sessionStart,
  106. PreToolUse: preToolUse,
  107. PostToolUse: postToolUse,
  108. Notification: notification,
  109. Stop: stop,
  110. SubagentStop: subagentStop,
  111. UserPromptSubmit: userPromptSubmit,
  112. PreCompact: preCompact,
  113. }).catch(error => {
  114. console.error('Hook error:', error)
  115. process.exit(1)
  116. })
  117. }
  118. main()

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.