@neolabhq

plan-do-check-act provides a structured four-phase iterative framework for continuous improvement, with detailed steps for hypothesis-driven experimentation, measurement, and standardization. includes concrete worked examples across infrastructure, testing, and process domains.

kaizen covers continuous improvement mindset applied to code, design, and systems through four pillars: incremental progress, error-proofing by design, standardized work, and building only what's needed now. includes code examples and anti-patterns.

create-workflow-command provides a templated approach to building multi-step orchestration commands that dispatch work to sub-agents via file-based task prompts, reducing context bloat in the main orchestrator.

cause-and-effect guides systematic fishbone analysis across six domains (people, process, technology, environment, methods, materials) to identify root causes rather than symptoms, with worked examples showing prioritization and solution mapping.

root-cause-tracing walks backward through call stacks to isolate the original trigger of deep errors rather than patching symptoms. it establishes a principle and decision framework but lacks concrete procedural steps.

create-agent documents the anatomy and construction of claude code agents, covering frontmatter rules, system prompt design, triggering patterns, and validation. provides templates and worked examples but lacks concrete failure mode discussion.

query searches fpf knowledge bases by keyword, id, or layer, returning hypothesis metadata with r_eff scores and dependency trees in structured table format.

launch-sub-agent routes tasks to appropriate language models and specialized agent profiles using zero-shot chain-of-thought reasoning and mandatory self-critique loops. covers complexity classification, model selection via decision tree, and structured prompt construction with verification gates.

setup-codemap-cli guides installation and configuration of codemap for codebase visualization, with support for project-level, personal, and global configuration scopes and optional hook integration.

create-pr wraps github cli to scaffold pull requests with conventional commit formatting and template enforcement, but lacks clarity on failure handling and recovery paths.

plan-task refines draft task specifications through parallel analysis, architectural synthesis, decomposition, and risk identification, moving validated work from draft to ready state.

multi-agent-patterns addresses context bottlenecks and task decomposition by distributing work across focused agent invocations. covers supervisor, peer-to-peer, and hierarchical patterns with emphasis on context isolation over role simulation.

create-hook guides users through git hook setup by analyzing project tooling, suggesting relevant hooks based on detected frameworks and scripts, and creating executable scripts with test validation.

fix-tests orchestrates parallel agent execution to repair broken test suites after logic changes, with conditional logic to avoid test rewriting on complex refactors. procedure lacks concrete sequencing and outcome signals.

do-and-judge implements a task execution pattern with meta-judge specification generation, parallel sub-agent dispatch, external verification, and retry loop. orchestrator role only, no direct tool execution.

write-tests orchestrates test creation for local code changes by analyzing complexity, delegating to specialized agents for multi-file scenarios, and verifying coverage iteratively. covers git-based change detection and conditional branching between simple and complex workflows.

judge-with-debate orchestrates multi-round consensus evaluation by deploying independent judges with shared rubrics and evidence-based argumentation, reducing individual bias through structured debate.

load-issues fetches open github issues via gh cli and persists them as markdown files in a specs directory with standardized naming and metadata structure.

decay detects and flags stale evidence in decisions, enabling time-aware risk governance through expiry tracking and waiver workflows.

test-skill applies red-green-refactor cycles to skill validation, requiring agents to fail without documentation before strengthening it. depends on pre-existing tdd knowledge and external examples.

review-local-changes orchestrates multi-agent code review of uncommitted changes with configurable impact filtering and output formats, but procedure execution relies heavily on external agent behavior without clear fallback or validation mechanisms.

create-command is a meta-skill documenting how to build claude commands with category classification, frontmatter requirements, and pattern research. actual command generation logic is absent.

agent-evaluation describes conceptual frameworks and research findings for assessing non-deterministic agent systems using multi-dimensional rubrics and lm-as-judge approaches, but lacks concrete implementation procedures.

write-concisely applies strunk and white grammar rules to documentation. lacks actionable procedure, decision logic, and concrete output validation.

implement-task orchestrates multi-step task execution with lmm-as-judge verification, but the skill document is itself a procedural system design rather than a reusable skill with clear trigger conditions or discrete, actionable outputs.

critique attempts a multi-agent review framework but lacks actionable step-by-step procedure, concrete trigger examples, and explicit failure handling. the skill reads as a template for debate orchestration rather than executable critique logic.

create-ideas generates six candidate responses via bimodal sampling (high confidence vs exploratory tail), but lacks concrete inputs, decision logic, and failure handling. procedural intent is visible but underspecified.

judge attempts to spawn evaluation agents but lacks concrete implementation details, procedural clarity, and failure handling. incomplete specification unsuitable for cross-vendor deployment.

Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures…

Use when adding metadata to commits without changing history, tracking review status, test results, code quality annotations, or supplementing commit messages…

Iterative Five Whys root cause analysis drilling from symptoms to fundamentals

Comprehensive A3 one-page problem analysis with root cause and action plan

Guide for setup Context7 MCP server to load documentation for specific technologies.

Auto-selects best Kaizen method (Gemba Walk, Value Stream, or Muda) for target

Launch multiple sub-agents in parallel to execute tasks across files or targets with intelligent model selection, quality-focused prompting, and meta-judge →…

creates draft task file in .specs/tasks/draft/ with original user intent

Use this skill when you writing commands, hooks, skills for Agent, or prompts for sub agents or any other LLM interaction, including optimizing prompts,…

Display the current state of the FPF knowledge base

Execute complete FPF cycle from hypothesis generation to decision

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when…

setup-arxiv-mcp — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Reset the FPF reasoning cycle to start fresh

review-pr — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Execute tasks through competitive multi-agent generation, meta-judge evaluation specification, multi-judge evaluation, and evidence-based synthesis

setup-serena-mcp — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Execute complex tasks through sequential sub-agent orchestration with intelligent model selection, meta-judge → LLM-as-a-judge verification

create-rule — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Use when creating or editing any prompt (commands, hooks, skills, subagent instructions) to verify it produces desired behavior - applies RED-GREEN-REFACTOR…

Guide 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…

Add line-specific review comments to pull requests using GitHub CLI API

Use when working on multiple branches simultaneously, context switching without stashing, reviewing PRs while developing, testing in isolation, or comparing…

Reconcile the project's FPF state with recent repository changes

Comprehensive guide for skill development based on Anthropic's official best practices - use for complex skills requiring detailed structure

Analyze a GitHub issue and create a detailed technical specification

Curates insights from reflections and critiques into CLAUDE.md using Agentic Context Engineering

subagent-driven-development — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Create well-formatted commits with conventional commit messages and emoji

Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning,…

Update and maintain project documentation for local code changes using multi-agent workflow with tech-writer agents. Covers docs/, READMEs, JSDoc, and API…

Reflect on previus response and output, based on Self-refinement framework for iterative improvement with complexity triage and verification

tree-of-thoughts — an installable skill for AI agents, published by neolabhq/context-engineering-kit.

Use when tackling complex reasoning tasks requiring step-by-step logic, multi-step arithmetic, commonsense reasoning, symbolic manipulation, or problems where…

Understand the components, mechanics, and constraints of context in agent systems. Use when writing, editing, or optimizing commands, skills, or sub-agents…