neolabhq/context-engineering-kit▌

This skill provides guidance for quality focused software development and architecture. It is based on Clean Architecture and Domain Driven Design principles.

Help turn ideas into fully formed designs and specs through natural collaborative dialogue.

Generate Ideas \n You are a helpful assistant. For each query, please generate a set of 6 possible responses, each as separate list item. Responses should each include a text and a numeric probability.\nPlease sample responses at random from the [full distribution / tails of the distribution], in such way that: \n \n For first 3 responses aim for high probability, over 0.80 \n For last 3 responses aim for diversity - explore different regions of the solution space, such that the probability of e

Your job is to help users merge changes from git worktrees into their current branch, supporting multiple merge strategies from simple file checkout to selective cherry-picking.

Reflect on previus response and output.

Load all open issues from the current GitHub repository and save them as markdown files in the ./specs/issues/ directory.

User Input:

Your job is to create well-formatted commits with conventional commit messages and emoji.

Multi-agent architectures distribute work across multiple agent invocations, each with its own focused context. When designed well, this distribution enables capabilities beyond single-agent limits. When designed poorly, it introduces coordination overhead that negates benefits. The critical insight is that sub-agents exist primarily to isolate context, not to anthropomorphize role division.

Create or update CLAUDE.md in with following content, write it strictly as it is, do not summaraise or introduce and new additional information:

Context is the complete state available to a language model at inference time. It includes everything the model can attend to when generating responses: system instructions, tool definitions, retrieved documents, message history, and tool outputs. Understanding context fundamentals is prerequisite to effective context engineering.

You are an expert code reviewer conducting a thorough evaluation of local uncommitted changes. Your review must be structured, systematic, and provide actionable feedback including improvement suggestions.

Before dispatching, analyze the task systematically. Think through step by step:

Advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability.

Create and execute plan by dispatching fresh subagent per task or issue, with code and output review after each or batch of tasks.

Search the FPF knowledge base and display hypothesis details with assurance information.

Execute the First Principles Framework (FPF) cycle: generate competing hypotheses, verify logic, validate evidence, audit trust, and produce a decision.

This command is a core part of maintaining a living assurance case. It keeps your FPF knowledge base (.fpf/) in sync with the evolving reality of your project's codebase.

Manages evidence freshness by identifying stale decisions and providing governance actions. Implements FPF B.3.4 (Evidence Decay).

Display the current state of the FPF knowledge base.

User Input:

User Input:

Git notes attach metadata to commits (or any Git object) without modifying the objects themselves. Notes are stored separately and displayed alongside commit messages.

To create high-quality MCP (Model Context Protocol) servers that enable LLMs to effectively interact with external services, use this skill. An MCP server provides tools that allow LLMs to access external services and APIs. The quality of an MCP server is measured by how well it enables LLMs to accomplish real-world tasks using the tools provided.

Apply Five Whys root cause analysis to investigate issues by iteratively asking "why" to drill from symptoms to root causes.

Please analyze GitHub issue #$ARGUMENTS and create a technical specification.

Your job is to create and setup git worktrees for parallel development, with automatic detection and installation of project dependencies.

This guide explains how to add line-specific review comments to pull requests using the GitHub CLI (gh) API or mcp__github_inline_comment__create_inline_comment if it not available, similar to how the GitHub UI allows commenting on specific lines of code.

Key features:

Apply Fishbone (Ishikawa) diagram analysis to systematically explore all potential causes of a problem across multiple categories.

Execute a single task by dispatching an implementation sub-agent, verifying with an independent judge, and iterating with feedback until passing or max retries exceeded.

This meta-command helps create other commands by:

Apply A3 problem-solving format for comprehensive, single-page problem documentation and resolution planning.

Analyze the project, suggest practical hooks, and create them with proper testing.

Intelligently select and apply the most appropriate Kaizen analysis technique based on what you're analyzing.

Key benefits:

Apply PDCA cycle for continuous improvement through iterative problem-solving and process optimization.

User can provide a what tests or modules to focus on:

Your job is to compare files and directories between git worktrees, helping users understand differences in code across branches or worktrees.

Apply continuous improvement mindset - suggest small iterative improvements, error-proof designs, follow established patterns, avoid over-engineering; automatically applied to guide quality and simplicity

Test skill provided by user or developed before.

Output must add precise, actionable bullets that future tasks can immediately apply.

Bugs often manifest deep in the call stack (git init in wrong directory, file created in wrong location, database opened with wrong path). Your instinct is to fix where the error appears, but that's treating a symptom.

Before launching the evaluation pipeline, identify what needs evaluation:

Apply Anthropic's official skill authoring best practices to your skill.

Evaluation of agent systems requires different approaches than traditional software or even standard language model applications. Agents make dynamic decisions, are non-deterministic between runs, and often lack single correct answers. Effective evaluation must account for these characteristics while providing actionable feedback. A robust evaluation framework enables continuous improvement, catches regressions, and validates that context engineering choices achieve intended effects.

The review is report-only - findings are presented for user consideration without automatic fixes.

$1f

This command provides guidance for creating effective skills.

This guide explains how to create pull requests using GitHub CLI in our project.

User can provide to focus on specific tests or modules:

Key benefits:

You are an expert code reviewer conducting a thorough evaluation of this pull request. Your review must be structured, systematic, and provide actionable feedback.

Chain-of-Thought (CoT) prompting and its variants encourage LLMs to generate intermediate reasoning steps before arriving at a final answer, significantly improving performance on complex reasoning tasks. These techniques transform how models approach problems by making implicit reasoning explicit.

William Strunk Jr.'s The Elements of Style (1918) teaches you to write clearly and cut ruthlessly. Apply these rules to task that requested by user.

Write the test first. Watch it fail. Write minimal code to pass.

User can provide specific focus areas or documentation types:

Your role is to create a draft task file that exactly matches the user's request.

You are a task refinement orchestrator. Take a draft task file created by /add-task and refine it through a coordinated multi-agent workflow with quality gates after each phase.

CRITICAL: You are the orchestrator only - you MUST NOT perform the task yourself. IF you read, write or run bash tools you failed task imidiatly. It is single most critical criteria for you. If you used anyting except sub-agents you will be killed immediatly!!!! Your role is to:

Key benefits:

Test any prompt before deployment: commands, hooks, skills, subagent instructions, or production LLM prompts.

User Input:

Git worktrees enable checking out multiple branches simultaneously in separate directories, all sharing the same repository. Create a worktree instead of stashing changes or cloning separately.

Your job is to implement solution in best quality using task specification and sub-agents. You MUST NOT stop until it critically neccesary or you are done! Avoid asking questions until it is critically neccesary! Launch implementation agent, judges, iterate till issues are fixed and then move to next step!

Reset the FPF reasoning cycle to start fresh.