### Install Specific Plugins

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/getting-started.md

Installs a specified plugin from the NeoLabHQ/context-engineering-kit marketplace. Examples include 'reflexion', 'code-review', and 'sdd'.

```bash
# Syntax
/plugin install <plugin-name>@NeoLabHQ/context-engineering-kit

# Examples
/plugin install reflexion@NeoLabHQ/context-engineering-kit
/plugin install code-review@NeoLabHQ/context-engineering-kit
/plugin install sdd@NeoLabHQ/context-engineering-kit
```

--------------------------------

### Codemap Usage Examples

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/setup-codemap-cli.md

Demonstrates how to invoke the setup command with different OS parameters and provides common CLI commands for codebase navigation.

```bash
# Standard setup with auto-detection
> /mcp:setup-codemap-cli

# Specify your OS
> /mcp:setup-codemap-cli macos
> /mcp:setup-codemap-cli windows

# Common CLI usage
codemap .                    # Project tree
codemap --only md .          # Just Markdown files
codemap --diff --ref master  # What changed vs master
codemap --deps .             # Dependency flow
```

--------------------------------

### Setup Context7 Documentation Tool

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/usage-examples.md

Sets up the Context7 tool to provide API documentation for specified libraries. This is useful for research and ensuring examples match current APIs.

```bash
> /mcp:setup-context7-mcp react, nextjs
```

```bash
> /mcp:setup-context7-mcp react, typescript, prisma
```

--------------------------------

### Example Project Initialization with Code Formatting

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/ddd/setup-code-formating.md

Demonstrates a typical sequence for initializing a project, including setting up TypeScript best practices and then configuring code formatting rules in CLAUDE.md. This ensures a consistent development environment from the start.

```bash
# Typically used during project initialization
/sdd:00-setup Use React, TypeScript, Node.js
/tech-stack:add-typescript-best-practices
/ddd:setup-code-formating
```

--------------------------------

### Install Individual Plugins

Source: https://context7.com/neolabhq/context-engineering-kit/llms.txt

Commands to install specific plugins from the Context Engineering Kit, such as Reflexion, SDD, and Code Review. Also includes an example for installing commonly used plugins.

```bash
# Install the Reflexion plugin for self-refinement loops
/plugin install reflexion@NeoLabHQ/context-engineering-kit

# Install the SDD plugin for specification-driven development
/plugin install sdd@NeoLabHQ/context-engineering-kit

# Install the Code Review plugin for multi-agent code review
/plugin install code-review@NeoLabHQ/context-engineering-kit

# Install all commonly used plugins
/plugin install git@NeoLabHQ/context-engineering-kit
/plugin install tdd@NeoLabHQ/context-engineering-kit
/plugin install sadd@NeoLabHQ/context-engineering-kit
/plugin install kaizen@NeoLabHQ/context-engineering-kit
```

--------------------------------

### Initialize Codemap CLI

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/setup-codemap-cli.md

Executes the setup command to install and configure Codemap. It supports optional OS-specific arguments to tailor the installation process.

```bash
/mcp:setup-codemap-cli [OS type or configuration preferences]
```

--------------------------------

### Setup and Use Codemap CLI

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/usage-examples.md

Installs and configures the Codemap CLI for codebase visualization and navigation. Includes commands for structure visualization, diffing, and dependency analysis.

```bash
/mcp:setup-codemap-cli
codemap .
codemap --diff --ref master
codemap --deps .
codemap --only ts,tsx .
```

--------------------------------

### CLAUDE.md Configuration Example

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/setup-context7-mcp.md

The resulting configuration snippet added to CLAUDE.md after running the setup command, which defines the available library IDs for the MCP server.

```markdown
### Use Context7 MCP for Loading Documentation

Context7 MCP is available to fetch up-to-date documentation with code examples.

**Recommended library IDs**:

- `react` - React core library documentation
- `typescript` - TypeScript language reference
- `prisma` - Prisma ORM documentation
```

--------------------------------

### Setup Serena MCP Server

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Guide for setting up the Serena MCP server. This server provides semantic code retrieval and editing capabilities, allowing LLMs to interact with code more intelligently.

```bash
/mcp:setup-serena-mcp
```

--------------------------------

### Install Specific Plugins with CEK

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/best-practices.md

Demonstrates how to install only necessary plugins to improve token efficiency, contrasting the recommended approach with an inefficient one.

```bash
# ❌ Don't install all plugins
/plugin install reflexion@NeoLabHQ/context-engineering-kit
/plugin install code-review@NeoLabHQ/context-engineering-kit
/plugin install sdd@NeoLabHQ/context-engineering-kit
# ... (if you won't use them all)

# ✅ Install only plugins that you expect to use
/plugin install reflexion@NeoLabHQ/context-engineering-kit  # For today's feature work
```

--------------------------------

### Install and Enable SDD Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sdd/README.md

Commands to install the SDD plugin from the marketplace and enable it within the environment. This is the first step to using the plugin's features.

```bash
/plugin marketplace add NeoLabHQ/context-engineering-kit
Enable the `sdd` plugin in the installed plugins list:
/plugin
# Installed -> sdd -> Space to enable
```

--------------------------------

### Setup arXiv MCP Server

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Guide for setting up the arXiv/Paper Search MCP server using Docker. This server enables academic paper search and retrieval from multiple sources, broadening LLM's knowledge base.

```bash
/mcp:setup-arxiv-mcp
```

--------------------------------

### Install and Enable SDD Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sdd/README.md

Commands to install the SDD plugin from the marketplace and enable it within the IDE.

```APIDOC
## Install and Enable SDD Plugin

### Description
Commands to install the SDD plugin from the marketplace and enable it within the IDE.

### Method
Bash Commands

### Endpoint
N/A

### Parameters
None

### Request Example
```bash
/plugin marketplace add NeoLabHQ/context-engineering-kit
```

### Response
#### Success Response (200)
Plugin installed successfully.

#### Response Example
```
NeoLabHQ/context-engineering-kit installed successfully.
```

## Enable SDD Plugin

### Description
Enable the 'sdd' plugin in the installed plugins list.

### Method
IDE Command

### Endpoint
N/A

### Parameters
None

### Request Example
```bash
/plugin
# Installed -> sdd -> Space to enable
```

### Response
#### Success Response (200)
Plugin enabled.

#### Response Example
```
SDD plugin is now enabled.
```
```

--------------------------------

### Install Marketplace via OpenSkills

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Alternative installation commands using OpenSkills to install and sync the Context Engineering Kit. This provides another way to manage skills and agents.

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

--------------------------------

### Install and Execute TDD Plugin Commands

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/tdd/README.md

Demonstrates how to install the TDD plugin and use the CLI to initiate test-driven development for a feature, followed by fixing any resulting test failures.

```bash
# Install the plugin
/plugin install tdd@NeoLabHQ/context-engineering-kit

> claude "Use TDD skill to implement email validation for user registration"

# Manually make some changes that cause test failures

# Fix failing tests
> /tdd:fix-tests
```

--------------------------------

### Example Compression in Documentation

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/create-skill/SKILL.md

Illustrates how to compress examples in documentation to save tokens. This involves minimizing conversational text and using concise placeholders for actions like dispatching subagents.

```markdown
# ❌ BAD: Verbose example (42 words)
your human partner: "How did we handle authentication errors in React Router before?"
You: I'll search past conversations for React Router authentication patterns.
[Dispatch subagent with search query: "React Router authentication error handling 401"]

# ✅ GOOD: Minimal example (20 words)
Partner: "How did we handle auth errors in React Router?"
You: Searching...
[Dispatch subagent → synthesis]
```

--------------------------------

### Implement npm ci and Binary Mirrors

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/kaizen/usage-examples.md

This section details the transition from 'npm install' to 'npm ci' and the configuration of binary mirrors for dependency installation. 'npm ci' is faster and more reliable as it uses the package-lock.json file. Configuring binary mirrors can further speed up installations by fetching pre-compiled packages, reducing build times when dependencies change.

```Shell
# Example of using npm ci in a CI script
npm ci

```

```npmrc
# .npmrc configuration for binary mirrors
registry=https://registry.npmjs.org/
# Example mirror configuration (replace with actual mirror URL if applicable)
# @my-scope:registry=https://my-private-mirror.com/registry/

```

--------------------------------

### Skill Directory Structure Example

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/create-skill/SKILL.md

Provides an example directory structure for a skill, showing the placement of the required SKILL.md file and optional bundled resources such as scripts, references, and assets.

```tree
skill-name/
├── SKILL.md (required)
│   ├── YAML frontmatter metadata (required)
│   │   ├── name: (required)
│   │   └── description: (required)
│   └── Markdown instructions (required)
└── Bundled Resources (optional)
    ├── scripts/          - Executable code (Python/Bash/etc.)
    ├── references/       - Documentation intended to be loaded into context as needed
    └── assets/           - Files used in output (templates, icons, fonts, etc.)
```

--------------------------------

### Install Reflexion Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/getting-started.md

Installs the Reflexion plugin from the NeoLabHQ/context-engineering-kit marketplace. This plugin provides commands for self-reflection, memorization, and critique, enhancing Claude's output.

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

--------------------------------

### Install and Execute SDD Workflow

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Commands to install the SDD plugin and execute the standard development lifecycle: adding a task, generating a plan, and implementing the feature.

```bash
/plugin install sdd@NeoLabHQ/context-engineering-kit
/sdd:add-task "Design and implement authentication middleware with JWT support"
/sdd:plan
/sdd:implement @.specs/tasks/todo/design-auth-middleware.feature.md
```

--------------------------------

### Code Example Verification Process

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/sdd/agents/tech-writer.md

This pseudocode outlines the systematic steps for verifying code examples within documentation. It involves listing all examples, executing them, capturing their output, and comparing it against the documented output to ensure accuracy. This process is crucial for maintaining user trust.

```pseudocode
Let me verify this documentation methodically:

Step 1: Code example verification
- List all code examples in the document
- For each example: execute it, capture output, compare to documented output
- Result: All pass / Found issues in examples X, Y

Step 2: API accuracy verification
- List all API endpoints, parameters, responses documented
- For each: verify their accuracy against actual implementation
- Result: All match / Discrepancies found in X, Y

Step 3: Reference validation
- List all file paths, links, version numbers
- For each: verify it exists and is current
- Result: All valid / Broken references: X, Y

Therefore: [Ready to publish / Must fix issues X, Y, Z before publishing]
```

--------------------------------

### Install MCP Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Command to install the MCP plugin, enabling integration with Model Context Protocol servers. This is the initial step for utilizing MCP functionalities.

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

--------------------------------

### Set Up New Project with CEK Agents

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/best-practices.md

Illustrates commands for setting up a new project, including establishing a constitution, adding language best practices, and configuring code formatting using SDD, tech-stack, and DDD agents.

```bash
# Establish constitution
/sdd:00-setup Use FastAPI, PostgreSQL, follow Clean Architecture

# Add language best practices
/tech-stack:add-typescript-best-practices

# Setup code quality standards
/ddd:setup-code-formating
```

--------------------------------

### Install and Configure Codemap CLI

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/guides/file-structure-context.md

This command installs and configures the Codemap CLI, setting up necessary hooks and updating documentation for AI integration. It handles OS-specific installations and verifies the setup.

```bash
/mcp:setup-codemap-cli
```

--------------------------------

### Install and Use Kaizen Plugin Commands

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/kaizen/README.md

Demonstrates how to install the Kaizen plugin and execute its core commands for root cause analysis, code analysis, and problem documentation. These commands help in systematically addressing issues and improving code quality.

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

> /kaizen:why "API returns 500 error on checkout"

> /kaizen:analyse src/checkout/

> /kaizen:analyse-problem "Database connection exhaustion during peak traffic"
```

--------------------------------

### Setup Complete MCP Tooling for Feature Development

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/usage-examples.md

Provides a comprehensive setup for a new project using MCP tools, including Context7 for documentation, Serena for semantic navigation, and Codemap for visualization.

```bash
> /mcp:setup-context7-mcp react, typescript, prisma
> /mcp:setup-serena-mcp
> /mcp:setup-codemap-cli
```

--------------------------------

### Define Commit Message Few-Shot Examples

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/apply-anthropic-skill-best-practices/SKILL.md

A template for guiding LLM output quality by providing input/output pairs for standardized commit message formatting.

```markdown
Input: Added user authentication with JWT tokens
Output:
feat(auth): implement JWT-based authentication

Add login endpoint and token validation middleware

Input: Fixed bug where dates displayed incorrectly in reports
Output:
fix(reports): correct date formatting in timezone conversion

Use UTC timestamps consistently across report generation
```

--------------------------------

### Example: Full Guided Mode Merge

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/git/merge-worktree.md

Demonstrates initiating the /git:merge-worktree command in full interactive/guided mode, which will prompt the user for necessary inputs.

```bash
> /git:merge-worktree --interactive
```

--------------------------------

### Install and Execute Git Plugin Commands

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/git/README.md

Demonstrates the installation of the Git plugin and the execution of core commands for creating commits and pull requests. These commands rely on the GitHub CLI for full functionality.

```bash
# Install the plugin
/plugin install git@NeoLabHQ/context-engineering-kit

# Create a well-formatted commit
> /git:commit

# Create a pull request
> /git:create-pr
```

--------------------------------

### Initialize Skill Directory and Documentation

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/create-skill/SKILL.md

Commands to create a new skill directory and the required SKILL.md file with YAML frontmatter for structured documentation.

```bash
mkdir -p skills/skill-name
touch skills/skill-name/SKILL.md
```

```markdown
---
name: skill-name
description: Use when [triggering conditions] - [what the skill does]
---

# Skill Name

## Critical Guidlines
[Core principle in 1-2 sentences. Each start wit "You MUST ..."]

## How to Use
[Think in steps, use problem decomposition, etc.]

## Guide
[Procedures, patterns]

## Examples
[Examples of how to use the skill, include agent input and output]

## Troubleshooting
[Common mistakes and how to avoid them]

## Resources
[Scripts, references, assets]
```

--------------------------------

### Priority Rule Example (Evaluation)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/create-rule/SKILL.md

A priority rule that guides the agent's evaluation process, setting clear priorities for correctness and penalizing incorrect answers.

```markdown
# Evaluation Priorities

Prioritize correctness over style.
Do not reward hallucinated detail.
Penalize confident wrong answers more than uncertain correct ones.
```

--------------------------------

### Few-Shot Chain-of-Thought Prompting Template

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/thought-based-reasoning/SKILL.md

A template for Few-Shot CoT prompting that provides the model with examples of questions and their step-by-step reasoning processes to guide future output.

```text
Q: Roger has 5 tennis balls. He buys 2 more cans of tennis balls. Each can has 3 tennis balls. How many tennis balls does he have now?
A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 tennis balls. 5 + 6 = 11. The answer is 11.

Q: The cafeteria had 23 apples. If they used 20 to make lunch and bought 6 more, how many apples do they have?
A: The cafeteria had 23 apples originally. They used 20 to make lunch. So they had 23 - 20 = 3. They bought 6 more apples, so they have 3 + 6 = 9. The answer is 9.

Q: [YOUR QUESTION HERE]
A:
```

--------------------------------

### Initial TypeScript Project Setup

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/tech-stack/usage-examples.md

This is a common pattern for setting up a new TypeScript project. It involves initializing the project, setting up the tech stack, adding TypeScript best practices, and configuring code formatting.

```bash
claude /init
/sdd:00-setup [your tech stack description]
/tech-stack:add-typescript-best-practices
/ddd:setup-code-formating
```

--------------------------------

### Setup Serena MCP Server

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/mcp/setup-serena-mcp.md

Initiates the setup process for the Serena MCP server, which provides semantic code retrieval and symbol-based editing. It can auto-detect client configurations or accept specific client types as arguments.

```bash
/mcp:setup-serena-mcp [configuration preferences]
```

```bash
# Standard setup with auto-detection
> /mcp:setup-serena-mcp

# Specify your client
> /mcp:setup-serena-mcp cursor

# With specific configuration needs
> /mcp:setup-serena-mcp claude-desktop
```

--------------------------------

### Automated Reflection Trigger

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Example showing how to use the 'reflect' keyword in the initial prompt to automatically trigger the reflection hook after Claude completes a task. Requires 'bun' to be installed.

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

--------------------------------

### Batch Execution with Checkpoints in SADD

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sadd/usage-examples.md

Shows how to execute a large refactoring plan in batches with defined checkpoints for review and feedback. This example details the command to start batch execution and the expected flow for multiple batches.

```bash
> Use subagent-driven development to execute specs/refactor/plan.md
  Execute in batches of 3 tasks with review between batches.
```

--------------------------------

### Query Documentation with Context7 MCP

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/CLAUDE.md

Fetches up-to-date documentation and code examples using the Context7 MCP. Requires a valid library ID and a query string. Outputs documentation relevant to the query.

```bash
mcp__context7__query-docs libraryId: "/anthropics/claude-code" query: "how to configure hooks"
```

--------------------------------

### Generate Tests for Microservice Modules (Bash)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/tdd/usage-examples.md

This example demonstrates generating comprehensive test coverage for a new microservice with multiple modules. It shows the workflow of implementing modules, then using a command to cover critical business logic across the entire service, followed by expected multi-agent orchestration for test writing.

```bash
# After implementing all modules
> claude "implement user service with CRUD operations, authentication, and notifications"

# Generate tests for entire service
> /tdd:write-tests Cover all critical business logic across the service
```

--------------------------------

### YAML Skill Description Examples

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/create-skill/SKILL.md

Illustrates effective and ineffective ways to write skill descriptions in YAML format. Good descriptions start with 'Use when...', clearly define the problem, and are technology-agnostic unless the skill is specific.

```yaml
# ❌ BAD: Too abstract, vague, doesn't include when to use
description: For async testing

# ❌ BAD: First person
description: I can help you with async tests when they're flaky

# ❌ BAD: Mentions technology but skill isn't specific to it
description: Use when tests use setTimeout/sleep and are flaky

# ✅ GOOD: Starts with "Use when", describes problem, then what it does
description: Use when tests have race conditions, timing dependencies, or pass/fail inconsistently - replaces arbitrary timeouts with condition polling for reliable async tests

# ✅ GOOD: Technology-specific skill with explicit trigger
description: Use when using React Router and handling authentication redirects - provides patterns for protected routes and auth state management
```

--------------------------------

### Prompt Optimization Example: Iterative Refinement

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/prompt-engineering/SKILL.md

Shows a progression of prompt optimization through iterative refinement, starting simple and adding constraints and reasoning to improve results. This method is crucial for production prompts where consistency and cost are important.

```markdown
Version 1 (Simple): "Summarize this article"
→ Result: Inconsistent length, misses key points

Version 2 (Add constraints): "Summarize in 3 bullet points"
→ Result: Better structure, but still misses nuance

Version 3 (Add reasoning): "Identify the 3 main findings, then summarize each"
→ Result: Consistent, accurate, captures key information
```

--------------------------------

### Usage Examples: Context Engineering Kit Commands

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/sdd/skills/plan/SKILL.md

Provides various command-line examples for using the Context Engineering Kit, demonstrating different modes like fast refinement, continuing from a specific stage, high-quality refinement with human checkpoints, and incremental refinement using the --refine flag.

```bash
# Refine a draft task with all stages
/plan .specs/tasks/draft/add-validation.feature.md
```

```bash
# Fast refinement with minimal stages
/plan .specs/tasks/draft/quick-fix.bug.md --fast
```

```bash
# Continue from a specific stage
/plan .specs/tasks/draft/complex-feature.feature.md --continue decomposition
```

```bash
# High-quality refinement with checkpoints
/plan .specs/tasks/draft/critical-api.feature.md --target-quality 4.5 --human-in-the-loop 2,3,4,5,6
```

```bash
# Incremental refinement after user edits (re-runs only affected stages)
/plan .specs/tasks/todo/my-task.feature.md --refine
```

--------------------------------

### Few-Shot Learning Example for Information Extraction

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/prompt-engineering/SKILL.md

Demonstrates few-shot learning by providing input-output pairs to guide the model in extracting key information from support tickets. This technique is useful for achieving consistent formatting and specific reasoning patterns.

```markdown
Extract key information from support tickets:

Input: "My login doesn't work and I keep getting error 403"
Output: {"issue": "authentication", "error_code": "403", "priority": "high"}

Input: "Feature request: add dark mode to settings"
Output: {"issue": "feature_request", "error_code": null, "priority": "low"}

Now process: "Can't upload files larger than 10MB, getting timeout"
```

--------------------------------

### YAML for Skill Description Update

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/test-skill/SKILL.md

This YAML snippet shows an example of updating a skill's description to include specific conditions and symptoms that might lead to rule violations. It aims to proactively guide the agent and prevent common mistakes.

```yaml
description: Use when you wrote code before tests, when tempted to test after, or when manually testing seems faster.
Add symptoms of ABOUT to violate.

```

--------------------------------

### SDD Plan Command Usage Examples

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sdd/plan.md

Demonstrates various ways to use the `/sdd:plan` command for refining tasks, including default refinement, fast refinement, one-shot execution, continuing from specific stages, high-quality refinement with human checkpoints, skipping research, and incremental refinement after editing.

```bash
# Refine a draft task with all stages (default)
/sdd:plan .specs/tasks/draft/add-validation.feature.md

# Fast refinement — minimal stages, lower quality bar
/sdd:plan .specs/tasks/draft/quick-fix.bug.md --fast

# One-shot — business analysis + decomposition only, no judges
/sdd:plan .specs/tasks/draft/simple-task.feature.md --one-shot

# Continue from a specific stage
/sdd:plan .specs/tasks/draft/complex-feature.feature.md --continue decomposition

# High-quality refinement with human review checkpoints
/sdd:plan .specs/tasks/draft/critical-api.feature.md --target-quality 4.5 --human-in-the-loop 2,3,4,5,6

# Skip research phase (you already know the tech stack)
/sdd:plan .specs/tasks/draft/my-task.feature.md --skip research

# Incremental refinement after editing the spec
/sdd:plan .specs/tasks/todo/my-task.feature.md --refine
```

--------------------------------

### Usage Examples for /git:analyze-issue

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/git/analyze-issue.md

Demonstrates various ways to use the '/git:analyze-issue' command, including analyzing a single issue before starting work, integrating it into a Software Development الدورة (SDD) workflow, and using it for sprint planning by analyzing multiple issues.

```bash
# Analyze issue before starting work
> /git:analyze-issue 123

# Use with SDD workflow
> /git:analyze-issue 123
> /sdd:01-specify

# Plan sprint work
> /git:load-issues
> /git:analyze-issue 45
> /git:analyze-issue 67
```

--------------------------------

### Organizing System Prompts with Markdown

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/context-engineering/SKILL.md

This example demonstrates how to structure system prompts using markdown sections like BACKGROUND_INFORMATION, INSTRUCTIONS, TOOL_GUIDANCE, and OUTPUT_DESCRIPTION. It specifies the programming language, version, and coding standards to be followed, along with guidance on tool usage.

```markdown
<BACKGROUND_INFORMATION>
You are a Python expert helping a development team.
Current project: Data processing pipeline in Python 3.9+
</BACKGROUND_INFORMATION>

<INSTRUCTIONS>
- Write clean, idiomatic Python code
- Include type hints for function signatures
- Add docstrings for public functions
- Follow PEP 8 style guidelines
</INSTRUCTIONS>

<TOOL_GUIDANCE>
Use bash for shell operations, python for code tasks.
File operations should use pathlib for cross-platform compatibility.
</TOOL_GUIDANCE>

<OUTPUT_DESCRIPTION>
Provide actionable feedback with specific line references.
Explain the reasoning behind suggestions.
</OUTPUT_DESCRIPTION>
```

--------------------------------

### Auto-CoT Step 1: Generate Diverse Demonstrations (Python)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/customaize-agent/skills/thought-based-reasoning/SKILL.md

Shows the initial step of the Auto-CoT (Automatic Chain of Thought) process, which involves clustering questions to identify diverse examples. These representative questions are then used to generate reasoning chains, automating the setup of few-shot CoT prompting.

```python
# Cluster questions
clusters = cluster_questions(all_questions, k=8)
```

--------------------------------

### Install Codemap CLI (Windows)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/mcp/skills/setup-codemap-cli/SKILL.md

Installs the Codemap CLI tool on Windows systems using the Scoop package manager. It adds the codemap repository to Scoop and then installs the package.

```bash
scoop bucket add codemap https://github.com/JordanCoin/scoop-codemap
scoop install codemap
```

--------------------------------

### Install Codemap CLI (macOS/Linux)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/mcp/skills/setup-codemap-cli/SKILL.md

Installs the Codemap CLI tool on macOS and Linux systems using the Homebrew package manager. It first taps the necessary repository and then installs the codemap package.

```bash
brew tap JordanCoin/tap && brew install codemap
```

--------------------------------

### Install Marketplace via npx skills

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/README.md

Command to install the Context Engineering Kit using the vercel-labs/skills tool in the terminal. This method allows users to pick specific skills and agents to install.

```bash
npx skills add NeoLabHQ/context-engineering-kit
```

--------------------------------

### Simple Feature Implementation with SDD Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sdd/usage-examples.md

Demonstrates the standard workflow for adding a new feature using the SDD plugin, including task creation, planning, implementation, and version control integration. It outlines the agents and stages involved in the `/sdd:plan` and `/sdd:implement` commands.

```bash
# Step 1: Create draft task
/sdd:add-task "Add user profile view and edit functionality with name, email, and avatar"

# Step 2: Plan — research, analyze, decompose, parallelize, verify
/sdd:plan @.specs/tasks/draft/add-user-profile.feature.md

# Step 3: Review specification (optional but recommended)
# Edit .specs/tasks/todo/add-user-profile.feature.md if needed
# Re-run planning for only affected sections:
/sdd:plan @.specs/tasks/todo/add-user-profile.feature.md --refine

# Step 4: Implement
/sdd:implement @.specs/tasks/todo/add-user-profile.feature.md

# Step 5: Commit and create PR
/git:commit
/git:create-pr
```

--------------------------------

### Rule Structure Example (TypeScript)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/sadd/agents/judge.md

Demonstrates the required structure for a rule, including frontmatter, rule name, description, and the contrastive pattern (Incorrect vs. Correct) with code examples. This example specifies TypeScript files.

```markdown
---
title: Short Rule Name
paths:
  - "src/**/*.ts"
---

# Rule Name

[1-2 sentence description of what the rule enforces and WHY it matters.]

## Incorrect

[Description of what is wrong with this pattern.]

```typescript
// Anti-pattern code or behavior example
```

## Correct

[Description of why this pattern is better.]

```typescript
// Recommended code or behavior example
```

## Reference

[Optional: links to documentation, papers, or related rules.]
```

--------------------------------

### Setup Reports Directory

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/sadd/skills/judge-with-debate/SKILL.md

Prepares the file system for storing evaluation reports generated by judge agents.

```bash
mkdir -p .specs/reports
```

--------------------------------

### Self-Critique Reasoning Process Example (Markdown)

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/sdd/agents/tech-writer.md

An example of a self-critique process for API documentation, detailing verification steps for accuracy, code examples, audience clarity, completeness, and link validity. It highlights findings and identifies gaps.

```markdown
Task: Verify API documentation I just created

Let me work through each verification question step by step:

Question 1: Accuracy Verification
- Let me list all technical claims made:
  1. Endpoint path: POST /api/v2/users
  2. Required parameter: email (string)
  3. Response code: 201 on success
- Now let me verify each against the actual code:
  1. Checking routes.ts... confirmed POST /api/v2/users ✓
  2. Checking handler... email required ✓, but also requires 'name' - MISSING!
  3. Checking response... returns 201 ✓
- Finding: FAIL - missing required 'name' parameter

Question 2: Code Example Testing
- Let me list all code examples:
  1. cURL example line 45
  2. JavaScript fetch example line 62
- Now let me execute each:
  1. Running cURL... ERROR: missing 'name' parameter (matches gap found above)
  2. Running JS fetch... same error
- Finding: FAIL - examples don't include 'name' parameter

Question 3: Audience Clarity
- Stated audience: "Frontend developers integrating user registration"
- Let me read as a frontend dev with no context:
  - Do I understand what this endpoint does? Yes, clear overview
  - Do I know what to send? Partially - email shown, but name missing
  - Do I know what I'll get back? Yes, response example shown
  - Are there unexplained terms? No jargon without explanation
- Finding: PARTIAL PASS - would fail at integration due to missing param

Question 4: Completeness
- Let me check coverage against implementation:
  - All endpoints documented? Yes (1 of 1)
  - All parameters? NO - missing 'name'
  - All error codes? Let me check handler... 400, 409, 500 documented ✓
  - Rate limits? Not in handler, N/A
- Finding: FAIL - missing 'name' parameter documentation

Question 5: Link Validity
- Let me list all links:
  1. ./auth/tokens.md - checking... EXISTS ✓
  2. https://example.com/api-guidelines - checking... 200 OK ✓
- Finding: PASS - all links valid

Therefore: Must fix 'name' parameter issue before publishing.
Gaps to address: Add 'name' parameter to docs and examples.
```

--------------------------------

### Install and Configure Tech Stack Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/tech-stack/README.md

This snippet demonstrates how to install the Tech Stack plugin and apply TypeScript best practices to a project. It involves running the installation command followed by the specific configuration command to update the CLAUDE.md file.

```bash
# Install the plugin
/plugin install tech-stack@NeoLabHQ/context-engineering-kit

# Add TypeScript best practices to your project
/tech-stack:add-typescript-best-practices

# Review the updated CLAUDE.md
cat CLAUDE.md
```

--------------------------------

### Create and Plan Task Specification with SDD Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/sdd/README.md

Demonstrates how to initiate a new development task and generate a detailed specification using the SDD plugin. The `/sdd:add-task` command creates the initial task file, and `/sdd:plan` refines it into a high-quality specification, moving it to the 'todo' state.

```bash
# Create the .specs/tasks/draft/design-auth-middleware.feature.md file with the initial prompt
/sdd:add-task "Design and implement authentication middleware with JWT support"

# Write a detailed specification for the task
/sdd:plan
# Moves the task to the .specs/tasks/todo/ folder
```

--------------------------------

### Install GitHub CLI

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/git/skills/create-pr/SKILL.md

Commands to install the GitHub CLI on various operating systems including macOS and Windows.

```bash
brew install gh
winget install --id GitHub.cli
```

--------------------------------

### Test Paper Search MCP Server Setup

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/plugins/mcp/skills/setup-arxiv-mcp/SKILL.md

This command executes a test query against the 'search_arxiv' tool provided by the 'paper-search' MCP server to verify the setup. It demonstrates how to pass arguments for a query and specify the maximum number of results.

```bash
mcp-exec name: "search_arxiv" arguments: {"query": "test query", "max_results": 2}
```

--------------------------------

### Install and Activate DDD Plugin

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/ddd/README.md

Commands to install the DDD plugin and trigger its rules during code generation or review tasks.

```bash
# Install the plugin
/plugin install ddd@NeoLabHQ/context-engineering-kit

# Ask Claude to use DDD rules
> claude "Use DDD rules to implement user authentication"
```

--------------------------------

### Implement Module Usage Example

Source: https://github.com/neolabhq/context-engineering-kit/blob/master/docs/plugins/docs/usage-examples.md

Provides a TypeScript example of how to import and use functions from a documented module, such as the payments module.

```typescript
import { createSubscription } from './payments';

const subscription = await createSubscription({
  customerId: 'cus_123',
  priceId: 'price_monthly',
  metadata: { userId: 'user_456' }
});
```