@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.

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.

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.

build-mcp provides a phased workflow for implementing MCP servers with agent-centric tool design principles, comprehensive planning, language-specific implementation paths, and evaluation frameworks. covers research, coding standards, testing constraints, and quality verification.

prompt-engineering covers five core techniques (few-shot learning, chain-of-thought, optimization, templates, system prompts) plus integration patterns, performance tuning, and persuasion principles for agent communication. practical but lacks decision trees for when to apply each pattern.

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.

status introspects the fpf knowledge base directory structure, counts hypotheses across layers, flags stale or expired evidence, and reports the current reasoning phase via formatted output.

propose-hypotheses executes a multi-stage first principles framework workflow: hypothesis generation, logic verification, evidence validation, trust audit, and final decision. relies on external fpf-agent with file-based state passing between numbered steps.

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.

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-pr wraps github cli to scaffold pull requests with conventional commit formatting and template enforcement, but lacks clarity on failure handling and recovery paths.

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.

meta-guidance on skill authoring principles from anthropic covering metadata design, model testing considerations, and optimization for token efficiency, but lacks actionable detail for actual skill construction.

attach-review-to-pr covers adding line-specific comments to pull requests via github cli api or mcp tools, with fallback paths for unavailable endpoints and guidance on single vs batch operations.

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.

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.

thought-based-reasoning catalogs chain-of-thought prompting variants (zero-shot, few-shot, tree of thoughts, react, pal, reflexion) with rough accuracy gains and deployment guidance, but lacks actionable procedure and failure mode discussion.

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.

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.

do-competitively orchestrates multi-agent task execution via competitive generation, meta-judge evaluation rubric synthesis, and evidence-based output merging. strategy selection adapts to confidence levels and cost constraints.

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

update-docs orchestrates multi-agent documentation workflows for local code changes, covering markdown files, readmes, and api specs, but lacks detailed procedural definition.

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.

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.

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

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.

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…

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

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

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.

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