Does context-engineering-kit auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Is context-engineering-kit free?

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

Plugin

context-engineering-kit

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

FLOW.md

neolabhq@neolabhq

GitHub

Plugin Signal95/100Strong

maintained100

capable100

documented100

adopted66

Install on Claude Code

> /plugin marketplace add NeoLabHQ/context-engineering-kit

Stats

Python TypeScript Node Bash Docker

+7 tags

Vercel Git GitHub Markdown Anthropic Gemini MCP

1,308

Stars

136

Forks

Active

Maintenance

TypeScript

Language

GPL-3.0

License

21h ago

Last commit

8mo ago

Created

Repo: NeoLabHQ/context-engineering-kit

In this plugin

68 skills 23 agents 1 command

See everything inside

What's inside

Skills

134

/agent-evaluationEvaluate and improve Claude Code commands, skills, and agents. Use when testing prompt effectiveness, validating context engineering choices, or measuring improvement quality./apply-anthropic-skill-best-practicesComprehensive guide for skill development based on Anthropic's official best practices - use for complex skills requiring detailed structure /context-engineeringUnderstand the components, mechanics, and constraints of context in agent systems. Use when writing, editing, or optimizing commands, skills, or sub-agents prompts./create-agentComprehensive guide for creating Claude Code agents with proper structure, triggering conditions, system prompts, and validation - combines official Anthropic best practices with proven patterns /create-commandInteractive assistant for creating new Claude commands with proper structure, patterns, and MCP tool integration /create-hookCreate and configure git hooks with intelligent project analysis, suggestions, and automated testing

Show all 134 skills

/create-ruleUse when found gap or repetative issue, that produced by you or implemenataion agent. Esentially use it each time when you say "You absolutly right, I should have done it differently." -> need create rule for this issue so it not appears again./create-skillGuide for creating effective skills. This command should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations. Use when creating new skills, editing existing /create-workflow-commandCreate a workflow command that orchestrates multi-step execution through sub-agents with file-based task prompts /prompt-engineeringUse this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates./test-promptUse when creating or editing any prompt (commands, hooks, skills, subagent instructions) to verify it produces desired behavior - applies RED-GREEN-REFACTOR cycle to prompt engineering using subagents for isolated testing /test-skillUse when creating or editing skills, before deployment, to verify they work under pressure and resist rationalization - applies RED-GREEN-REFACTOR cycle to process documentation by running baseline without skill, writing to address failures, iterating to close loopholes /thought-based-reasoningUse when tackling complex reasoning tasks requiring step-by-step logic, multi-step arithmetic, commonsense reasoning, symbolic manipulation, or problems where simple prompting fails - provides comprehensive guide to Chain-of-Thought and related prompting techniques (Zero-shot /actualizeReconcile the project's FPF state with recent repository changes /decayManage evidence freshness by identifying stale decisions and providing governance actions /propose-hypothesesExecute complete FPF cycle from hypothesis generation to decision /querySearch the FPF knowledge base and display hypothesis details with assurance information /resetReset the FPF reasoning cycle to start fresh /statusDisplay the current state of the FPF knowledge base /analyze-issueAnalyze a GitHub issue and create a detailed technical specification /attach-review-to-prAdd line-specific review comments to pull requests using GitHub CLI API /commitCreate well-formatted commits with conventional commit messages and emoji /create-prCreate pull requests using GitHub CLI with proper templates and formatting /git-notesUse when adding metadata to commits without changing history, tracking review status, test results, code quality annotations, or supplementing commit messages post-hoc - provides git notes commands and patterns for attaching non-invasive metadata to Git objects./git-worktreesUse when working on multiple branches simultaneously, context switching without stashing, reviewing PRs while developing, testing in isolation, or comparing implementations across branches - provides git worktree commands and workflow patterns for parallel development with /load-issuesLoad all open issues from GitHub and save them as markdown files /load-pr-commentsUse to load open/unresolved PR review comments then aggregate them as tasks in .specs/comments/*.md for parallel agents to fix./resolve-fixed-pr-commentsVerify what PR review comments have been addressed (committed/pushed OR uncommitted local changes) and resolve the threads that are genuinely fixed or no longer relevant./analyse-problemComprehensive A3 one-page problem analysis with root cause and action plan /analyseAuto-selects best Kaizen method (Gemba Walk, Value Stream, or Muda) for target /cause-and-effectSystematic Fishbone analysis exploring problem causes across six categories /kaizenUse when Code implementation and refactoring, architecturing or designing systems, process and workflow improvements, error handling and validation. Provide tehniquest to avoid over-engineering and apply iterative improvements./plan-do-check-actIterative PDCA cycle for systematic experimentation and continuous improvement /root-cause-tracingUse when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior /whyIterative Five Whys root cause analysis drilling from symptoms to fundamentals /build-mcpGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK)./setup-arxiv-mcpGuide for setup arXiv paper search MCP server using Docker MCP /setup-codemap-cliGuide for setup Codemap CLI for intelligent codebase visualization and navigation /setup-context7-mcpGuide for setup Context7 MCP server to load documentation for specific technologies./setup-serena-mcpGuide for setup Serena MCP server for semantic code retrieval and editing capabilities /critiqueComprehensive multi-perspective review using specialized judges with debate and consensus building /memorizeCurates insights from reflections and critiques into CLAUDE.md using Agentic Context Engineering /reflectReflect on previus response and output, based on Self-refinement framework for iterative improvement with complexity triage and verification /review-local-changesReview your local uncommitted working-tree changes (git diff plus untracked files) and return actionable improvement suggestions. Use before committing, when nothing has been pushed yet./review-prReview an existing GitHub pull request and post inline review comments on its diff. Use when the changes are on an opened PR rather than your local working tree./traiage-reviewThis skill should be used when need prioritize what changed code in repository human must review./do-and-judgeExecute a task with sub-agent implementation and LLM-as-a-judge verification with automatic retry loop /do-competitivelyExecute tasks through competitive multi-agent generation, meta-judge evaluation specification, multi-judge evaluation, and evidence-based synthesis /do-in-parallelRun independent tasks concurrently across multiple files or targets using parallel sub-agents, with per-task model selection and LLM-as-a-judge verification. Use when tasks do not depend on each other and can run side by side./do-in-stepsExecute one complex task as ordered, dependent steps run sequentially, passing context from each step to the next, with per-step LLM-as-a-judge verification. Use when later steps depend on the results of earlier ones./judge-with-debateEvaluate solutions through multi-round debate between independent judges until consensus /judgeLaunch a meta-judge then a judge sub-agent to evaluate results produced in the current conversation /launch-sub-agentLaunch an intelligent sub-agent with automatic model selection based on task complexity, specialized agent matching, Zero-shot CoT reasoning, and mandatory self-critique verification /multi-agent-patternsDesign multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality./subagent-driven-developmentUse when executing implementation plans with independent tasks in the current session or facing 3+ independent issues that can be investigated without shared state or dependencies - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration /tree-of-thoughtsExecute tasks through systematic exploration, pruning, and expansion using Tree of Thoughts methodology with meta-judge evaluation specifications and multi-agent evaluation /add-taskcreates draft task file in .specs/tasks/draft/ with original user intent /brainstormUse when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes /create-ideasGenerate ideas in one shot using creative sampling /implement-taskImplement a task with automated LLM-as-Judge verification per step /plan-taskRefine, parallelize, and verify a draft task specification into a fully planned implementation-ready task /design-testing-strategyUse before writing any type of tests. Distills 14 industry sources into deterministic decision gates, schemas, and worked test examples./fix-testsSystematically fix all failing tests after business logic changes or refactoring /test-coverageUse after writing tests to assess coverage quality across structural, mutation, requirements, and API/integration dimensions; organized knowledge for choosing and interpreting coverage analyses./test-driven-developmentUse when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first /write-testsAdd missing test coverage for your local code changes by generating new test files (covers uncommitted and untracked changes, or the latest commit if everything is committed). Use when you want write tests for new logic or increase test coverage./actualizeReconcile the project's FPF state with recent repository changes /add-taskcreates draft task file in .specs/tasks/draft/ with original user intent /agent-evaluationEvaluate and improve Claude Code commands, skills, and agents. Use when testing prompt effectiveness, validating context engineering choices, or measuring improvement quality./analyse-problemComprehensive A3 one-page problem analysis with root cause and action plan /analyseAuto-selects best Kaizen method (Gemba Walk, Value Stream, or Muda) for target /analyze-issueAnalyze a GitHub issue and create a detailed technical specification /apply-anthropic-skill-best-practicesComprehensive guide for skill development based on Anthropic's official best practices - use for complex skills requiring detailed structure /attach-review-to-prAdd line-specific review comments to pull requests using GitHub CLI API /brainstormUse when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes /build-mcpGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK)./cause-and-effectSystematic Fishbone analysis exploring problem causes across six categories /commitCreate well-formatted commits with conventional commit messages and emoji /context-engineeringUnderstand the components, mechanics, and constraints of context in agent systems. Use when writing, editing, or optimizing commands, skills, or sub-agents prompts./create-agentComprehensive guide for creating Claude Code agents with proper structure, triggering conditions, system prompts, and validation - combines official Anthropic best practices with proven patterns /create-commandInteractive assistant for creating new Claude commands with proper structure, patterns, and MCP tool integration /create-hookCreate and configure git hooks with intelligent project analysis, suggestions, and automated testing /create-ideasGenerate ideas in one shot using creative sampling /create-prCreate pull requests using GitHub CLI with proper templates and formatting /create-ruleUse when found gap or repetative issue, that produced by you or implemenataion agent. Esentially use it each time when you say "You absolutly right, I should have done it differently." -> need create rule for this issue so it not appears again./create-skillGuide for creating effective skills. This command should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations. Use when creating new skills, editing existing /create-workflow-commandCreate a workflow command that orchestrates multi-step execution through sub-agents with file-based task prompts /critiqueComprehensive multi-perspective review using specialized judges with debate and consensus building /decayManage evidence freshness by identifying stale decisions and providing governance actions /design-testing-strategyUse before writing any type of tests. Distills 14 industry sources into deterministic decision gates, schemas, and worked test examples./do-and-judgeExecute a task with sub-agent implementation and LLM-as-a-judge verification with automatic retry loop /do-competitivelyExecute tasks through competitive multi-agent generation, meta-judge evaluation specification, multi-judge evaluation, and evidence-based synthesis /do-in-parallelRun independent tasks concurrently across multiple files or targets using parallel sub-agents, with per-task model selection and LLM-as-a-judge verification. Use when tasks do not depend on each other and can run side by side./do-in-stepsExecute one complex task as ordered, dependent steps run sequentially, passing context from each step to the next, with per-step LLM-as-a-judge verification. Use when later steps depend on the results of earlier ones./fix-testsSystematically fix all failing tests after business logic changes or refactoring /git-notesUse when adding metadata to commits without changing history, tracking review status, test results, code quality annotations, or supplementing commit messages post-hoc - provides git notes commands and patterns for attaching non-invasive metadata to Git objects./git-worktreesUse when working on multiple branches simultaneously, context switching without stashing, reviewing PRs while developing, testing in isolation, or comparing implementations across branches - provides git worktree commands and workflow patterns for parallel development with /implement-taskImplement a task with automated LLM-as-Judge verification per step /judge-with-debateEvaluate solutions through multi-round debate between independent judges until consensus /judgeLaunch a meta-judge then a judge sub-agent to evaluate results produced in the current conversation /kaizenUse when Code implementation and refactoring, architecturing or designing systems, process and workflow improvements, error handling and validation. Provide tehniquest to avoid over-engineering and apply iterative improvements./launch-sub-agentLaunch an intelligent sub-agent with automatic model selection based on task complexity, specialized agent matching, Zero-shot CoT reasoning, and mandatory self-critique verification /load-issuesLoad all open issues from GitHub and save them as markdown files /load-pr-commentsUse to load open/unresolved PR review comments then aggregate them as tasks in .specs/comments/*.md for parallel agents to fix./memorizeCurates insights from reflections and critiques into CLAUDE.md using Agentic Context Engineering /multi-agent-patternsDesign multi-agent architectures for complex tasks. Use when single-agent context limits are exceeded, when tasks decompose naturally into subtasks, or when specializing agents improves quality./plan-do-check-actIterative PDCA cycle for systematic experimentation and continuous improvement /plan-taskRefine, parallelize, and verify a draft task specification into a fully planned implementation-ready task /prompt-engineeringUse this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts, improving LLM outputs, or designing production prompt templates./propose-hypothesesExecute complete FPF cycle from hypothesis generation to decision /querySearch the FPF knowledge base and display hypothesis details with assurance information /reflectReflect on previus response and output, based on Self-refinement framework for iterative improvement with complexity triage and verification /resetReset the FPF reasoning cycle to start fresh /resolve-fixed-pr-commentsVerify what PR review comments have been addressed (committed/pushed OR uncommitted local changes) and resolve the threads that are genuinely fixed or no longer relevant./review-local-changesReview your local uncommitted working-tree changes (git diff plus untracked files) and return actionable improvement suggestions. Use before committing, when nothing has been pushed yet./review-prReview an existing GitHub pull request and post inline review comments on its diff. Use when the changes are on an opened PR rather than your local working tree./root-cause-tracingUse when errors occur deep in execution and you need to trace back to find the original trigger - systematically traces bugs backward through call stack, adding instrumentation when needed, to identify source of invalid data or incorrect behavior /setup-arxiv-mcpGuide for setup arXiv paper search MCP server using Docker MCP /setup-codemap-cliGuide for setup Codemap CLI for intelligent codebase visualization and navigation /setup-context7-mcpGuide for setup Context7 MCP server to load documentation for specific technologies./setup-serena-mcpGuide for setup Serena MCP server for semantic code retrieval and editing capabilities /statusDisplay the current state of the FPF knowledge base /subagent-driven-developmentUse when executing implementation plans with independent tasks in the current session or facing 3+ independent issues that can be investigated without shared state or dependencies - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration /test-coverageUse after writing tests to assess coverage quality across structural, mutation, requirements, and API/integration dimensions; organized knowledge for choosing and interpreting coverage analyses./test-driven-developmentUse when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first /test-promptUse when creating or editing any prompt (commands, hooks, skills, subagent instructions) to verify it produces desired behavior - applies RED-GREEN-REFACTOR cycle to prompt engineering using subagents for isolated testing /test-skillUse when creating or editing skills, before deployment, to verify they work under pressure and resist rationalization - applies RED-GREEN-REFACTOR cycle to process documentation by running baseline without skill, writing to address failures, iterating to close loopholes /thought-based-reasoningUse when tackling complex reasoning tasks requiring step-by-step logic, multi-step arithmetic, commonsense reasoning, symbolic manipulation, or problems where simple prompting fails - provides comprehensive guide to Chain-of-Thought and related prompting techniques (Zero-shot /traiage-reviewThis skill should be used when need prioritize what changed code in repository human must review./tree-of-thoughtsExecute tasks through systematic exploration, pruning, and expansion using Tree of Thoughts methodology with meta-judge evaluation specifications and multi-agent evaluation /update-docsUpdate and maintain project documentation for local code changes using multi-agent workflow with tech-writer agents. Covers docs/, READMEs, JSDoc, and API documentation./whyIterative Five Whys root cause analysis drilling from symptoms to fundamentals /write-conciselyApply writing rules to any documentation that humans will read. Makes your writing clearer, stronger, and more professional./write-testsAdd missing test coverage for your local code changes by generating new test files (covers uncommitted and untracked changes, or the latest commit if everything is committed). Use when you want write tests for new logic or increase test coverage.

Agents

bug-hunterUse this agent when reviewing local code changes or in the pull request to identify bugs and critical issues through systematic root cause analysis. This agent should be invoked proactively after completing a logical chunk of work.business-analystUse this agent when refining task descriptions and creating acceptance criteria for implementation tasks.change-expectation-agentUse this agent to rate each changed file based on 2 criteria and output final list of files that require most attention.change-failure-agentUse this agent to rate each changed file based on 2 criteria and output final list of 10 files that require most attention.change-impact-agentUse this agent to rate each changed file based on 4 criteria and output final list of 10 files that require most attention.change-story-agentUse this agent to build "story" of this change, that will be used to review it by human reviewer. Story must explain what this change tries to achive, what risks it introduces and how it solve them.

Show all 23 agents

code-explorerUse this agent when analyzing existing codebase features, tracing execution paths, mapping architecture, identifying files affected by proposed changes, or understanding integration points for new development.code-quality-reviewerUse this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, or for reviwing pull request changes.code-reviewerUse this agent to verify implementation against verification specification AND review code quality. Receives the task specification path and step number. Applies the per-step rubric/checklist, the built-in code quality evaluation specification, Muda waste analysis, and test contracts-reviewerUse this agent when reviewing local code changes or pull requests to analyze API, data models, and type design. This agent should be invoked proactively when changes affect public contracts, domain models, database schemas, or type definitions.developerUse this agent when implementing tasks from task files with implementation steps. Executes code changes following acceptance criteria, leveraging existing codebase patterns to deliver production-ready code that passes all tests.fpf-agentFirst Principles Framework reasoning specialist that executes hypothesis generation, verification, validation, and trust calculus tasks using the ADI (Abduction-Deduction-Induction) cycle and knowledge layer progression (L0/L1/L2)historical-context-reviewerUse this agent when reviewing local code changes or pull requests to understand the historical context of modified code, including past issues, patterns, and lessons learned. This agent should be invoked to prevent repeating past mistakes and to ensure consistency with previous judgeUse this agent when evaluating implementation artifacts against an evaluation specification produced by the meta judge. Applies rubric dimensions, checklist items, and scoring metadata to produce structured verdicts with self-verification and contrastive rule generation when meta-judgeUse this agent when generating evaluation rubrics, checklists, criteria, metrics, and weights for a user prompt BEFORE implementation begins. Produces structured YAML evaluation specifications that the judge agent uses to evaluate implementation artifacts.qa-engineerUse this agent when adding LLM-as-Judge verification sections to implementation steps in task files. Produces structured per-step evaluation specifications (rubrics, checklists with default quality items, scoring metadata) — Hard Rules + TICK decomposition, principles researcherUse this agent when researching unknown technologies, libraries, frameworks, and dependencies to gather relevant resources and documentation for implementation tasks. Creates reusable skills that all agents can leverage.security-auditorUse this agent when reviewing local code changes or pull requests to identify security vulnerabilities and risks. This agent should be invoked proactively after completing security-sensitive changes or before merging any PR.software-architectUse this agent when synthesizing research findings, codebase analysis, and business requirements into architectural solutions for task specifications.team-leadUse this agent when reorganizing implementation steps for maximum parallel execution with explicit dependency tracking and agent assignments. Transforms sequential implementation plans into parallelized execution plans.tech-leadUse this agent when breaking down architecture into implementation steps with success criteria, dependencies, and risk assessment. Transforms architectural blueprints into executable task sequences with proper ordering and parallelization opportunities.tech-writerCreates and maintains comprehensive, accessible technical documentation by transforming complex concepts into clear, structured content that helps users accomplish their tasks test-coverage-reviewerUse this agent when you need to review local code changes or a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or tests updated, to ensure tests adequately cover new functionality and edge cases.

Commands

/bump-pluginBump changed plugin and marketplace version

Badges

README

Read on GitHub

Advanced context engineering techniques and patterns for Claude Code, OpenCode, Cursor, Antigravity and more.

Quick Start · Plugins · Github Action · Reference · Docs

Context Engineering Kit

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

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.

Key Features

Simple to Use - Easy to install and use without any dependencies. Contains automatically used skills and self-explanatory commands.
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.
Quality-Focused - Each plugin is focused on meaningfully improving agent results in a specific area.
Granular - Install only the plugins you need. Each plugin loads only its specific agents, commands, and skills, without overlap or redundant skills.
Scientifically proven - Plugins are based on proven techniques and patterns validated by reputable benchmarks and studies.
Open-Standards - Skills are based on agentskills.io specification. The SDD plugin is based on the Arc42 specification standard for software development documentation.

News

Updates from key releases:

v3.1.0: Improved Spec-Driven Development plugin 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.
v3.0.0: Added support for AMP and Hermes agents. Tech Stack plugin now automatically injects typescript best practices when agent reads or writes TypeScript files.
v2.2.0: Subagent-Driven Development plugin now works as a distilled version of SDD plugin using meta-judge and judge sub-agents for specification generation on the fly and in parallel to implementation. DDD plugin now includes Clean Architecture, DDD, SOLID, Functional Programming, and other pattern examples as rules that are automatically added to the context during code writing.
v2.1.0: Spec-Driven Development plugin agents include high-level code quality guidelines from DDD plugin.
v2.0.0: Spec-Driven Development plugin was rewritten from scratch. It is now able to produce working code in 99% of cases on real-life production projects!

Quick Start

Step 1: Install Marketplace and Plugins

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.

Gemini CLI installation

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

Antigravity CLI installation:

Important: This command requires Gemini CLI to be installed.

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

Antigravity CLI installation without Gemini CLI:

git clone https://github.com/NeoLabHQ/context-engineering-kit
cd context-engineering-kit
agy plugin install .

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 and Antigravity CLI does not support per-plugin selection. But you can delete skills and agents that you don't need, after installation.

Run the 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.

You can use OpenSkills to install skills by running the following commands:

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

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.

Documentation

You can find the complete Context Engineering Kit documentation here.

However, the main plugins we recommend starting with are Subagent-Driven Development and Spec-Driven Development.

Agent Reliability Engineering

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:

Reliability metrics are based on more than year of real development usage on production projects.

Plugins List

To view all available plugins:

/plugin

Reflexion - Introduces feedback and refinement loops to improve output quality.
Spec-Driven Development - Introduces commands for specification-driven development, based on Continuous Learning + LLM-as-Judge + Agent Swarm. Achieves development as compilation through reliable code generation.
Review - Introduces code and PR review commands and skills using multiple specialized agents with impact/confidence filtering.
Git - Introduces commands for commit and PR creation.
Test-Driven Development - Introduces commands for test-driven development and common anti-patterns, plus skills for testing using subagents.
Subagent-Driven Development - Introduces skills for subagent-driven development, which dispatches a fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates.
Domain-Driven Development - Introduces 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.
FPF - First Principles Framework - Introduces 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.
Kaizen - Inspired by Japanese continuous improvement philosophy, Agile and Lean development practices. Introduces commands for analysis of root causes of issues and problems, including 5 Whys, Cause and Effect Analysis, and other techniques.
Customaize Agent - Commands and skills for writing and refining commands, hooks, and skills for Claude Code. Includes Anthropic Best Practices and Agent Persuasion Principles that can be useful for sub-agent workflows.
Docs - Commands for analyzing projects, writing and refining documentation.
Tech Stack - Rules for language-specific best practices, automatically applied when working on matching file types.
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.

Stay ahead

Star Context Engineering Kit on GitHub to support its development and get notified about new features and updates.

Reflexion

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.

How to install

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

Commands

/reflect - Reflect on the previous response and output based on the self-refinement framework for iterative improvement with complexity triage and verification
/memorize - Curate insights from reflections and critiques into CLAUDE.md using Agentic Context Engineering
/critique - Comprehensive multi-perspective review using specialized judges with debate and consensus building

Hooks

Automatic Reflection Hook - Triggers /reflect automatically when "reflect" appears in your prompt

Theoretical Foundation

The plugin is based on papers like Self-Refine and Reflexion. These techniques improve the output of large language models by introducing feedback and refinement loops.

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.

On top of that, the plugin is based on the Agentic Context Engineering paper, which uses memory updates after reflection and consistently outperforms strong baselines by 10.6% in agent applications.

Review

Comprehensive code and PR review commands that use multiple specialized agents for thorough code quality evaluation with impact/confidence filtering.

How to install

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

Commands

/review-local-changes - Comprehensive review of local uncommitted changes using specialized agents with code improvement suggestions
/review-pr - Comprehensive pull request review using specialized agents
/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.

Agents

This plugin uses multiple specialized agents for comprehensive code quality analysis:

bug-hunter - Identifies potential bugs, edge cases, and error-prone patterns
code-quality-reviewer - Evaluates code structure, readability, and maintainability
contracts-reviewer - Reviews interfaces, API contracts, and data models
historical-context-reviewer - Analyzes changes in relation to codebase history and patterns
security-auditor - Identifies security vulnerabilities and potential attack vectors
test-coverage-reviewer - Evaluates test coverage and suggests missing test cases

The traiage-review skill additionally uses four change-triage agents:

**change-story-agent
change-impact-agent
change-failure-agent
change-expectation-agent

You can use this plugin to review code in GitHub Actions; to do so, follow this guide.

Git

Commands and skills for streamlined Git operations including commits, pull request creation, and advanced workflow patterns.

How to install

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

Commands

/commit - Create well-formatted commits with conventional commit messages and emoji
/create-pr - Create pull requests using GitHub CLI with proper templates and formatting
/analyze-issue - Analyze a GitHub issue and create a detailed technical specification
/load-issues - Load all open issues from GitHub and save them as markdown files
/load-pr-comments - Load open/unresolved PR review comments and group them as tasks for parallel agents to fix.
/worktree - Create, compare, and merge git worktrees for parallel development with automatic dependency installation

Skills

git-notes - Skill for using git notes to add metadata to commits without changing history.
resolve-fixed-pr-comments - Verify what PR review comments have been addressed and resolve that are genuinely fixed or no longer relevant.

Test-Driven Development

Commands and skills for test-driven development with anti-pattern detection.

How to install

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

Commands

/write-tests - Systematically add test coverage for local code changes using specialized review and development agents
/fix-tests - Fix failing tests after business logic changes or refactoring using orchestrated agents

Skills

test-driven-development - Introduces TDD methodology, best practices, and skills for testing using subagents
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.
test-coverage - Manual for choosing, applying, different types of coverage analysis (structural, mutation, requirements, API/integration) on an existing test suite.

Subagent-Driven Development

Execution framework for competitive generation, multi-agent evaluation, and subagent-driven development with quality gates.

How to install

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

Commands

/launch-sub-agent - Launch focused sub-agents with intelligent model selection, Zero-shot CoT reasoning, and self-critique verification
/do-and-judge - Execute a single task with implementation sub-agent, independent judge verification, and automatic retry loop until passing
/do-in-parallel - Execute the same task across multiple independent targets in parallel with context isolation
/do-in-steps - Execute complex tasks through sequential sub-agent orchestration with automatic decomposition and context passing
/do-competitively - Execute tasks through competitive generation, multi-judge evaluation, and evidence-based synthesis to produce superior results
/tree-of-thoughts - Execute complex reasoning through systematic exploration of solution space, pruning unpromising branches, and synthesizing the best solution
/judge-with-debate - Evaluate solutions through iterative multi-judge debate with consensus building or disagreement reporting
/judge - Evaluate completed work using LLM-as-Judge with structured rubrics and evidence-based scoring

Skills

subagent-driven-development - Dispatches a fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
multi-agent-patterns - Design multi-agent architectures (supervisor, peer-to-peer, hierarchical) for complex tasks exceeding single-agent context limits

Spec-Driven Development

Comprehensive specification-driven development workflow plugin that transforms prompts into production-ready implementations through structured planning, architecture design, and quality-gated execution.

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.

Key Features

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.
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.
Customizable — Balance result quality and process speed by adjusting command parameters. Learn more in the Customization section.
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.
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.
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.
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.

Quick Start

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

Then run the following commands:

# create .specs/tasks/draft/design-auth-middleware.feature.md file with initial prompt
/add-task "Design and implement authentication middleware with JWT support"

# write detailed specification for the task
/plan-task
# will move task to .specs/tasks/todo/ folder

Restart the Claude Code session to clear context and start fresh. Then run the following command:

# implement the task
/implement-task @.specs/tasks/todo/design-auth-middleware.feature.md
# produces working implementation and moves the task to .specs/tasks/done/ folder

Commands

/add-task - Create task template file with initial prompt
/plan-task - Analyze prompt, generate required skills and refine task specification
/implement-task - Produce a working implementation of the task and verify it

Additional commands useful before creating a task:

/create-ideas - Generate diverse ideas on a given topic using creative sampling techniques
/brainstorm - Refine vague ideas into fully-formed designs through collaborative dialogue

Agents

Agent	Description	Used By
`researcher`	Technology research, dependency analysis, best practices	`/plan-task` (Phase 2a)
`code-explorer`	Codebase analysis, pattern identification, architecture mapping	`/plan-task` (Phase 2b)
`business-analyst`	Requirements discovery, stakeholder analysis, specification writing	`/plan-task` (Phase 2c)
`software-architect`	Architecture design, component design, implementation planning	`/plan-task` (Phase 3)
`tech-lead`	Task decomposition, dependency mapping, risk analysis	`/plan-task` (Phase 4)
`team-lead`	Step parallelization, agent assignment, execution planning	`/plan-task` (Phase 5)
`qa-engineer`	Verification rubrics, quality gates, LLM-as-Judge definitions	`/plan-task` (Phase 6)
`developer`	Code implementation, TDD execution, quality review, verification	`/implement-task`
`code-reviewer`	Verifies implementation against the per-step verification spec and evaluates code quality	`/implement-task`
`tech-writer`	Technical documentation writing, API guides, architecture updates, lessons learned	`/implement-task`

Patterns

Key patterns implemented in this plugin:

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.
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.
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.
Continuous learning — Builds skills that the agent needs to implement a specific task, which it would otherwise not be able to perform from scratch.
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.
MAKER — An agent reliability pattern introduced in Solving a Million-Step LLM Task with Zero Errors. It removes agent mistakes caused by accumulated context and hallucinations by utilizing clean-state agent launches, filesystem-based memory storage, and multi-agent voting during critical decision-making.

Vibe Coding vs. Specification-Driven Development

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.

To improve quality, after generating a specification you can correct it or leave comments using //, then run the /plan 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.

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.

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.

Learn more about available customization options in Customization.

Domain-Driven Development

Code quality framework with rules for Clean Architecture, SOLID principles, and Domain-Driven Design patterns.

How to install

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

Rules

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

FPF - First Principles Framework

A structured reasoning plugin that implements the First Principles Framework (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.

Key principles:

Transparent reasoning - Full audit trail from hypothesis to decision
Hypothesis-driven - Generate 3-5 competing alternatives before evaluating
Evidence-based - Computed trust scores, not estimates
Human-in-the-loop - AI generates options; humans decide (Transformer Mandate)

The core cycle follows three modes of inference:

Abduction — Generate competing hypotheses (don't anchor on the first idea).
Deduction — Verify logic and constraints (does the idea make sense?).
Induction — Gather evidence through tests or research (does the idea work in reality?).

Then, audit for bias, decide, and document the rationale in a durable record.

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.

How to install

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

Usage workflow

# Execute complete FPF cycle from hypothesis to decision
/propose-hypotheses What caching strategy should we use?

# The workflow will:
# 1. Initialize context and .fpf/ directory
# 2. Generate competing hypotheses
# 3. Allow you to add your own alternatives
# 4. Verify each against project constraints (parallel)
# 5. Validate with evidence (parallel)
# 6. Compute trust scores (parallel)
# 7. Present comparison for your decision

Commands

/propose-hypotheses - Execute complete FPF cycle from hypothesis to decision (main workflow)
/status - Show current FPF phase and hypothesis counts
/query - Search knowledge base with assurance info
/decay - Manage evidence freshness (refresh/deprecate/waive)
/actualize - Reconcile knowledge with codebase changes
/reset - Archive session and return to IDLE

Agent

fpf-agent - FPF reasoning specialist for hypothesis generation, verification, validation, and trust calculus using ADI cycle and knowledge layer progression

Kaizen

Continuous improvement methodology inspired by Japanese philosophy and Agile practices.

How to install

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

Commands

/analyse - Auto-selects best Kaizen method (Gemba Walk, Value Stream, or Muda) for target analysis
/analyse-problem - Comprehensive A3 one-page problem analysis with root cause and action plan
/why - Iterative Five Whys root cause analysis drilling from symptoms to fundamentals
/root-cause-tracing - Systematically traces bugs backward through call stack to identify source of invalid data or incorrect behavior
/cause-and-effect - Systematic Fishbone analysis exploring problem causes across six categories
/plan-do-check-act - Iterative PDCA cycle for systematic experimentation and continuous improvement

Skills

kaizen - Continuous improvement methodology with multiple analysis techniques

Customaize Agent

Commands and skills for creating and refining Claude Code extensions.

How to install

/plugin install customaize-agent@NeoLabHQ/context-engineering-kit

Commands

/create-agent - Comprehensive guide for creating Claude Code agents with proper structure, triggering conditions, system prompts, and validation
/create-command - Interactive assistant for creating new Claude commands with proper structure and patterns
/create-workflow-command - Create workflow commands that orchestrate multi-step execution through sub-agents with file-based task prompts
/create-skill - Guide for creating effective skills with test-driven approach
/create-hook - Create and configure git hooks with intelligent project analysis and automated testing
/test-skill - Verify skills work under pressure and resist rationalization using RED-GREEN-REFACTOR cycle
/test-prompt - Test any prompt (commands, hooks, skills, subagent instructions) using RED-GREEN-REFACTOR cycle with subagents
/apply-anthropic-skill-best-practices - Comprehensive guide for skill development based on Anthropic's official best practices

Skills

prompt-engineering - Well-known prompt engineering techniques and patterns, includes Anthropic Best Practices and Agent Persuasion Principles
context-engineering - Deep understanding of context mechanics: attention budget, progressive disclosure, lost-in-middle effect, and practical optimization patterns
agent-evaluation - Evaluation frameworks for agent systems: LLM-as-Judge, multi-dimensional rubrics, bias mitigation, and the 95% performance finding

Docs

Commands for project analysis and documentation management based on proven writing principles.

How to install

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

Commands

/update-docs - Update implementation documentation after completing development phases
/write-concisely - Apply The Elements of Style principles to make documentation clearer and more professional

Tech Stack

Rules for language and framework-specific best practices, automatically applied when the agent works on matching file types.

How to install

/plugin install tech-stack@NeoLabHQ/context-engineering-kit

Rules

TypeScript Best Practices - Type system guidelines, code style, async patterns, and code quality standards, automatically loaded when the agent reads or writes .ts files

MCP

Commands for integrating Model Context Protocol servers with your project. Each setup command supports configuration at multiple levels:

Project level (shared) - Configuration tracked in git, shared with team via ./CLAUDE.md
Project level (personal) - Local configuration in ./CLAUDE.local.md, not tracked in git
User level (global) - Configuration in ~/.claude/CLAUDE.md, applies to all projects

How to install

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

Commands

/setup-context7-mcp - Guide for setting up Context7 MCP server to load documentation for specific technologies
/setup-serena-mcp - Guide for setting up Serena MCP server for semantic code retrieval and editing capabilities
/setup-codemap-cli - Guide for setting up Codemap CLI for intelligent codebase visualization and navigation
/setup-arxiv-mcp - Guide for setting up arXiv/Paper Search MCP server via Docker MCP for academic paper search and retrieval from multiple sources
/build-mcp - Guide for creating high-quality MCP servers that enable LLMs to interact with external services

Theoretical Foundation

This project is based on research and papers from the following sources:

Self-Refine - Core refinement loop
Reflexion - Memory integration
Constitutional AI - Principle-based critique
LLM-as-a-Judge - Evaluation patterns
Multi-Agent Debate - Multiple perspectives
Agentic Context Engineering - Memory curation
Chain-of-Verification - Hallucination reduction
Tree of Thoughts - Structured exploration
Process Reward Models - Step-by-step evaluation
Verbalized Sampling - Diverse idea generation with 2-3x improvement
Process Reward Models - Step verification
Chain of Thought Prompting - Step-by-step reasoning
Inference-Time Scaling of Verification - Rubric-guided verification

More details about the theoretical foundation can be found on the resources page.

File tree

417

NeoLabHQ/context-engineering-kitView on GitHub

.claude/
.claude-plugin/
  marketplace.json
  commands/
    bump-plugin.md
  rules/
    grounded-instruction-references.md
    refactor-cross-references.md
  skills/
    .gitkeep
.cursor/
  worktrees.json
.devcontainer/
  devcontainer-lock.json
  devcontainer.json
.gitbook.yaml
.github/
  workflows/
    sync-provider-formats.yml
.gitignore
.specs/
  analysis/
    .gitkeep
  anthropic-claude-code-action-prompt.md
  reports/
    compare-worktrees-step-2-2026-01-30.md
    create-worktree-step-1-2026-01-30.md
    do-competitively-analysis.md
    do-in-parallel-2026-01-01.1.md
    do-in-parallel-2026-01-01.2.md
    do-in-parallel-2026-01-01.3.md
    do-in-steps-2026-01-01.1.md
    do-in-steps-2026-01-01.2.md
    do-in-steps-2026-01-01.3.md
    merge-worktree-step-3-2026-01-30.md
  research/
    claude-agent-resources.md
    research-resources.md
  tasks/
    done/
      .gitkeep
      add-compare-worktrees-command.feature.md
      add-create-worktree-command.feature.md
      add-gemini-antigravity-cli-support.feature.md
      add-merge-worktree-command.feature.md
    draft/
      .gitkeep
      add-code-quality-improvements.feature.md
      add-meta-judge.feature.md
      add-template-markdown-generation.feature.md
      migrate-commands-skills-format.refactor.md
      migrate-installer-openskills-vercel.feature.md
    in-progress/
      .gitkeep
    roadmap.md
    todo/
      .gitkeep
  usefull-prompts.md
agents/
  bug-hunter.md
  business-analyst.md
  change-expectation-agent.md
  change-failure-agent.md
  change-impact-agent.md
  change-story-agent.md
  code-explorer.md
  code-quality-reviewer.md
  code-reviewer.md
  contracts-reviewer.md
  developer.md
  fpf-agent.md
  historical-context-reviewer.md
  judge.md
  meta-judge.md
  qa-engineer.md
  researcher.md
  security-auditor.md
  software-architect.md
  team-lead.md
  tech-lead.md
  tech-writer.md
  test-coverage-reviewer.md
CLAUDE.md
CONTRIBUTING.md
docs/
  .gitbook/
    assets/
      Context-Engineering-Kit6.png
  assets/
    context-engineering-kit-like.gif
    Context-Engineering-Kit6.png
  best-practices.md
  concepts.md
  getting-started.md
  guides/
    brainstorming-to-implementation.md
    bug-investigation.md
    ci-integration.md
    code-quality-improvement.md
    competitivy-generation.md
    custom-extensions.md
    decision-making.md
    feature-development.md
    file-structure-context.md
    pr-review.md
    README.md
    spec-driven-development.md
  plugins/
    customaize-agent/
      agent-evaluation.md
      apply-anthropic-skill-best-practices.md
      context-engineering.md
      create-agent.md
      create-command.md
      create-hook.md
      create-skill.md
      create-workflow-command.md
      prompt-engineering.md
      README.md
      test-prompt.md
      test-skill.md
      usage-examples.md
    ddd/
      README.md
      rules.md
      usage-examples.md
    docs/
      README.md
      update-docs.md
      usage-examples.md
      write-concisely.md
    fpf/
      architecture.md
      evidence-freshness.md
      README.md
    git/
      analyze-issue.md
      attach-review-to-pr.md
      commit.md
      create-pr.md
      git-notes.md
      git-worktrees.md
      load-issues.md
      load-pr-comments.md
      README.md
      resolve-fixed-pr-comments.md
    kaizen/
      analyse-problem.md
      analyse.md
      cause-and-effect.md
      kaizen.md
      plan-do-check-act.md
      README.md
      root-cause-tracing.md
      usage-examples.md
      why.md
    mcp/
      build-mcp.md
      README.md
      recommended-mcp.md
      setup-arxiv-mcp.md
      setup-codemap-cli.md
      setup-context7-mcp.md
      setup-serena-mcp.md
      usage-examples.md
    README.md
    reflexion/
      critique.md
      memorize.md
      README.md
      reflect.md
      usage-examples.md
    review/
      README.md
      review-local-changes.md
      review-pr.md
      traiage-review.md
      usage-examples.md
    sadd/
      do-and-judge.md
      do-competitively.md
      do-in-parallel.md
      do-in-steps.md
      judge-with-debate.md
      judge.md
      launch-sub-agent.md
      multi-agent-patterns.md
      README.md
      subagent-driven-development.md
      tree-of-thoughts.md
      usage-examples.md
    sdd/
      add-task.md
      brainstorm.md
      create-ideas.md
      customization.md
      implement-task.md
      plan-task.md
      README.md
      refine.md
      usage-examples.md
    tdd/
      design-testing-strategy.md
      fix-tests.md
      README.md
      test-coverage.md
      test-driven-development.md
      usage-examples.md
      write-tests.md
    tech-stack/
      README.md
      typescript-best-practices.md
  README.md
  reference/
    agents.md
    commands.md
    README.md
    skills.md
  resources/
    papers.md
    README.md
    related-projects.md
  SUMMARY.md
gemini-extension.json
justfile
LICENSE
plugin.json
plugins/
  customaize-agent/
    .claude-plugin/
      plugin.json
    README.md
    skills/
      agent-evaluation/
        SKILL.md
      apply-anthropic-skill-best-practices/
        SKILL.md
      context-engineering/
        SKILL.md
      create-agent/
        SKILL.md
      create-command/
        SKILL.md
      create-hook/
        SKILL.md
      create-rule/
        SKILL.md
      create-skill/
        SKILL.md
      create-workflow-command/
        SKILL.md
      prompt-engineering/
        SKILL.md
      test-prompt/
        SKILL.md
      test-skill/
        SKILL.md
      thought-based-reasoning/
        SKILL.md
  ddd/
    .claude-plugin/
      plugin.json
    README.md
    rules/
      avoid-code-duplication.md
      boy-scout-rule.md
      call-site-honesty.md
      clean-architecture-ddd.md
      command-query-separation.md
      domain-specific-naming.md
      early-return-pattern.md
      error-handling.md
      explicit-control-flow.md
      explicit-data-flow.md
      explicit-side-effects.md
      function-file-size-limits.md
      functional-core-imperative-shell.md
      library-first-approach.md
      parallel-async-execution.md
      principle-of-least-astonishment.md
      separation-of-concerns.md
  docs/
    .claude-plugin/
      plugin.json
    README.md
    skills/
      update-docs/
        SKILL.md
      write-concisely/
        SKILL.md
  fpf/
    .claude-plugin/
      plugin.json
    agents/
      fpf-agent.md
    README.md
    skills/
      actualize/
        SKILL.md
      decay/
        SKILL.md
      propose-hypotheses/
        SKILL.md
      query/
        SKILL.md
      reset/
        SKILL.md
      status/
        SKILL.md
    tasks/
      add-user-hypothesis.md
      audit-trust.md
      decide.md
      generate-hypotheses.md
      init-context.md
      validate-evidence.md
      verify-logic.md
  git/
    .claude-plugin/
      plugin.json
    README.md
    skills/
      analyze-issue/
        SKILL.md
      attach-review-to-pr/
        SKILL.md
      commit/
        SKILL.md
      create-pr/
        SKILL.md
      git-notes/
        SKILL.md
      git-worktrees/
        SKILL.md
      load-issues/
        SKILL.md
      load-pr-comments/
        SKILL.md
      resolve-fixed-pr-comments/
        SKILL.md
  kaizen/
    .claude-plugin/
      plugin.json
    README.md
    skills/
      analyse/
      analyse-problem/
        SKILL.md
        SKILL.md
      cause-and-effect/
        SKILL.md
      kaizen/
        SKILL.md
      plan-do-check-act/
        SKILL.md
      root-cause-tracing/
        SKILL.md
      why/
        SKILL.md
  mcp/
    .claude-plugin/
      plugin.json
    README.md
    skills/
      build-mcp/
        SKILL.md
      setup-arxiv-mcp/
        SKILL.md
      setup-codemap-cli/
        SKILL.md
      setup-context7-mcp/
        SKILL.md
      setup-serena-mcp/
        SKILL.md
  README.md
  reflexion/
    .claude-plugin/
      plugin.json
    hooks/
      .gitignore
      bun.lockb
      hooks.json
      package.json
      README.md
      src/
        index.ts
        lib.ts
        onStopHandler.test.ts
        onStopHandler.ts
        session.ts
      tsconfig.json
      vitest.config.ts
    README.md
    skills/
      critique/
        SKILL.md
      memorize/
        SKILL.md
      reflect/
        SKILL.md
... 244 more

FAQ

context-engineering-kit is a Claude Code plugin with 134 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes agent-evaluation, apply-anthropic-skill-best-practices, context-engineering. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is context-engineering-kit?: A hand-crafted collection of advanced context engineering techniques and patterns with minimal token footprint, focused on improving agent result quality and predictability.
How do I install context-engineering-kit?: Run these in Claude Code: /plugin marketplace add NeoLabHQ/context-engineering-kit. Then prompt normally.
Does context-engineering-kit auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is context-engineering-kit free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.