Context Engineering Kit
Hand-crafted Claude Code skills and plugins that improve agent result quality with minimal token footprint, compatible with multiple agent tools.
Evidence shows: repository provides installation commands but does not clearly state permission scope; some commands (e.g., /commit, /create-pr) may perform external actions but no user confirmation mechanism is mentioned; data flow transparency is lacking as README mentions automatic reflection hooks but does not explain how data flows or if it is uploaded; no sensitive data handling documentation; dependencies require bun and npx skills but no security audit; external effects may modify files or execute git operations without impact scope; no rollback mechanism; source attribution mentions papers and internal use but lacks specific sources. Deductions: lack of clear evidence for least privilege, user confirmation, data flow transparency, sensitive data handling, dependency security, external effects, rollback, and source attribution.
Evidence shows: README and plugin list are generally consistent in functionality descriptions, but no internal consistency tests; dependency availability mentions bun and npx skills but no guarantee; failure messages not provided. Deductions: lack of explicit dependency availability and failure message documentation.
Evidence shows: README clearly defines target audience (developers) and use cases (improving agent result quality), provides multiple installation methods; capability boundaries list plugins but not specific limitations; trigger precision describes automatic reflection hook but not trigger conditions; environment fit supports multiple CLIs but lacks compatibility details. Deductions: capability boundaries and trigger precision descriptions are not detailed.
Evidence shows: README provides clear information architecture including quick start, plugin list, documentation links; installation notes detailed covering multiple CLIs; naming stable and consistent; examples and FAQ provided (e.g., usage examples); known limitations mention Gemini CLI lacks per-plugin selection but not comprehensive; license is GPL-3.0; versioning changelog in News section but no formal CHANGELOG; maintenance responsibility not clearly stated. Deductions: known limitations not comprehensive, maintenance responsibility unclear.
Evidence shows: output usability provides commands and skills but no actual output examples; marginal value claims improved result quality but no independent verification; cost-benefit provides token overhead estimates but no actual measurements. Deductions: lack of actual output examples and independent verification.
Evidence shows: README cites papers and benchmarks but lacks specific links or data; cross-source corroboration not provided; fact-inference separation claims reliability metrics based on one year of use but no data. Deductions: lack of traceable citations and independent verification.
- The repository lacks security details such as least privilege, user confirmation, and data flow transparency; assess before use.
- Dependencies (e.g., bun, npx skills) availability and security are not explicit; verify environment compatibility.
- Claimed reliability metrics lack independent verification; treat with caution.
What does this agent do, and when should you use it?
Context Engineering Kit is a plugin marketplace maintained by NeoLabHQ, offering a collection of advanced context engineering techniques and patterns for AI coding agents like Claude Code, OpenCode, Cursor, and Antigravity. The marketplace is built on prompts used daily by the developers, supplemented by plugins from benchmarked papers and high-quality projects. Key features include: no dependencies, easy installation; each plugin loads only its specific agents, commands, and skills, avoiding context bloat; and plugins are based on scientifically proven techniques such as Self-Refine, Reflexion, and LLM-as-Judge. The marketplace includes plugins for Reflexion (reflection and refinement), Spec-Driven Development (SDD), Subagent-Driven Development (SADD), Review, TDD, Git, Domain-Driven Development (DDD), and more. Installation varies by platform: Claude Code uses /plugin commands, Gemini/Antigravity use gemini extensions, and other tools like Cursor and OpenCode use npx skills.
The kit provides a set of plugins, each consisting of commands, skills, and agents that enhance the agent's coding workflow. For example, the Reflexion plugin provides /reflect, /memorize, and /critique commands, which use feedback loops and memory updates to improve output quality. The Spec-Driven Development (SDD) plugin offers /add-task, /plan-task, and /implement-task commands, which use multi-agent orchestration, LLM-as-Judge quality gates, and continuous learning to transform a prompt into working code. The Review plugin provides /review-local-changes and /review-pr, using specialized agents to perform comprehensive code reviews. The Git plugin offers /commit and /create-pr to streamline git operations. Subagent-Driven Development (SADD) provides /do-and-judge and /do-in-steps, enabling fast iteration with quality gates. Other plugins like Kaizen, Customaize Agent, Docs, Tech Stack, and MCP cover problem analysis, agent customization, documentation, tech stack rules, and MCP server setup.
- A developer wants to reduce hallucinations and errors from AI coding tools by including 'reflect' in prompts or running /reflect to have the agent analyze and fix missed requirements.
- A team needs reliable code generation for complex tasks, using the SDD plugin's /plan-task and /implement-task to turn specifications into working implementations with quality gates.
- A developer wants comprehensive code review before merging, using the Review plugin's /review-pr or /review-local-changes, which employ multiple specialized agents to check for bugs, security, test coverage, etc.
- A project needs test-driven development discipline, using the TDD plugin's /write-tests and /fix-tests to generate tests and fix failing ones.
- A developer wants to improve git workflow, using the Git plugin's /commit and /create-pr to produce conventional commit messages and pull requests.
- A technical lead wants structured, auditable reasoning for decision-making, using the FPF plugin's /propose-hypotheses for hypothesis-driven analysis.
What are this agent's strengths and limitations?
- Granular installation with minimal token overhead due to per-plugin loading.
- Based on scientifically validated techniques (Self-Refine, Reflexion, LLM-as-Judge) and benchmarked papers.
- SDD plugin claims 99% working code on real production projects, with reliability data table.
- Supports multiple agent platforms (Claude Code, Gemini CLI, Cursor) with flexible installation methods.
- Plugins are built on real-world developer usage, tested over time.
- Open standards: skills follow agentskills.io spec, SDD based on arc42 standard.
- Non-Claude Code platforms (Gemini CLI, Cursor) may lack full functionality, such as subagent support or per-plugin selection.
- Some plugins like FPF require large token loads (~600k tokens), potentially fast token consumption.
- Reliability claims are based on internal testing and may not be generalizable.
- Using /reflect hook requires installing bun, an additional dependency.
- GitHub Actions integration requires setup and may involve permission configuration.
- Marketplace requires trusting the repository source, posing supply chain risk.
How do you install or deploy this agent?
For Claude Code, in Claude Code run: /plugin marketplace add NeoLabHQ/context-engineering-kit, then install desired plugins, e.g., /plugin install reflexion@NeoLabHQ/context-engineering-kit. For Gemini CLI or Antigravity CLI, run gemini extensions install https://github.com/NeoLabHQ/context-engineering-kit (for Antigravity also agy plugin import gemini); alternatively clone the repo and run agy plugin install .. For Cursor, Codex, OpenCode, etc., run npx skills add NeoLabHQ/context-engineering-kit and select skills. Note: non-Claude Code platforms may not support per-plugin selection and npx skills does not support subagents.
How do you use this agent?
After installing the Reflexion plugin, in Claude Code run: claude "implement user authentication, then reflect", and the agent will execute and optionally trigger the /reflect hook (requires bun). Alternatively, run claude "implement user authentication", then manually run /reflect to analyze results and suggest improvements. For the SDD plugin, first run /add-task "Design and implement authentication middleware" to create a task file, then /plan-task to generate a spec, restart session, and run /implement-task @.specs/tasks/todo/design-auth-middleware.feature.md to implement.