neolabhq/context-engineering-kit
70 skills57.7k installs89.7k starsGitHub
Install
npx skills add https://github.com/neolabhq/context-engineering-kitSkills in this repo
1Prompt Engineeringprompt-engineering is a Claude Code skill from neolabhq/context-engineering-kit covering advanced prompt design for agent systems. It applies techniques like few-shot learning with 2–5 input-output example pairs, chain-of-thought structuring, output formatting controls, and production prompt templates. The skill triggers when writing commands, hooks, skills for agents, sub-agent prompts, or optimizing LLM reliability and controllability. Developers reach for prompt-engineering when agent outputs are inconsistent, hooks misfire, or sub-agent handoffs need tighter instruction design before shipping agent features.1kinstalls2Context Engineeringcontext-engineering is a Claude Code skill from neolabhq/context-engineering-kit that explains how inference-time context is assembled—system instructions, tool definitions, retrieved documents, message history, and tool outputs—and how each component affects agent reliability. Developers use it when writing, editing, or optimizing commands, skills, or sub-agent prompts where token limits and attention constraints break workflows. The skill walks through context fundamentals, mechanics, and constraints so you can budget tokens and disclose information progressively instead of stuffing oversized prompts. Reach for context-engineering before scaling multi-tool agents or debugging inconsistent sub-agent behavior.1kinstalls3Thought Based Reasoningthought-based-reasoning is a Neolab context-engineering skill that documents research-backed prompting methods including Zero-shot CoT, Self-Consistency, Tree of Thoughts, Least-to-Most, ReAct, PAL, and Reflexion. It supplies templates, decision matrices, and selection guidance so agents break complex reasoning, math, planning, and symbolic tasks into intermediate steps before final answers. Developers reach for thought-based-reasoning when agent workflows stall on arithmetic, commonsense chains, or multi-hop planning that flat prompts cannot solve. The skill is methodology-focused: it improves prompt design and reasoning structure rather than shipping application code or model weights.975installs4Reflectreflect is a skill from neolabhq/context-engineering-kit that turns the agent into a critical quality gatekeeper using a self-refinement and iterative improvement framework. It supports optional focus areas such as security and confidence thresholds—for example deep reflect if confidence is below 90%—plus complexity triage before verification. Developers reach for reflect when agent drafts look plausible but need structured flaw-finding, revision loops, and rejection of substandard work before merge or ship. The skill fits any workflow where AI output must pass a deliberate second-pass critique rather than ship on first generation.967installs5Brainstormbrainstorm is a context-engineering-kit Claude skill for refining rough ideas into fully formed designs and specifications through collaborative dialogue. It starts by understanding current project context, asks questions one at a time to narrow scope, explores alternatives, and incrementally validates assumptions before presenting a design. The skill accepts an optional initial feature concept, topic, or draft specification file as an argument hint. Developers reach for brainstorm when a feature idea is still vague, when they need structured discovery before writing code or implementation plans, and explicitly not during mechanical execution tasks where requirements are already clear and implementation steps are predetermined.944installs6Multi Agent PatternsMulti-Agent Patterns is a Claude Code skill from neolabhq/context-engineering-kit for engineers architecting Claude Code multi-agent workflows. It explains when to split work into sub-agents, how to isolate context per subtask, and why sub-agents exist primarily for context boundaries rather than cosmetic role play. The skill covers decomposition triggers, coordination overhead tradeoffs, and patterns that preserve quality when tasks naturally split across files, services, or verification steps. Developers reach for Multi-Agent Patterns when a monolithic agent loses thread on large repos, when specialized passes improve review or implementation quality, or when designing spawner-style agent pipelines for complex projects.943installs7Update Docsupdate-docs is a neolabhq/context-engineering-kit skill that maintains project documentation after local code changes using a multi-agent workflow with tech-writer agents. It updates docs/, README files, JSDoc comments, and API reference material while avoiding documentation bloat. Developers can scope work by target directory, documentation type (api, guides, readme, jsdoc), or a specific focus area. The skill fits teams where code and docs drift quickly and manual rewrites block merges. Reach for update-docs after feature changes when READMEs, API docs, or inline JSDoc must reflect the current codebase accurately.943installs8Subagent Driven Developmentsubagent-driven-development is a neolabhq/context-engineering-kit skill for executing implementation plans when three or more independent issues or tasks lack shared state dependencies. The core principle is fresh subagent per task plus review between or after tasks for fast iteration with quality gates. It keeps work in the same session—no context switch—while preventing context pollution from long-running monolithic agent threads. Developers reach for it when a plan lists parallelizable fixes, separate investigations, or batchable features that each deserve a clean agent context and a review checkpoint before moving on.941installs9Critiquecritique is a context-engineering-kit Claude skill implementing a Multi-Agent Debate plus LLM-as-a-Judge review pattern for completed work. A critique coordinator assigns specialized judges who independently review supplied file paths, commits, or recent changes, debate findings, and build consensus on correctness, quality, and improvement opportunities. Developers reach for critique after finishing a feature, design doc, or refactor when they want structured adversarial review rather than a single-pass lint or shallow summary. The skill defaults to recent changes when no explicit paths are provided, making it suited to pre-merge or pre-release quality gates where blind spots in architecture, logic, or documentation must be surfaced before shipping.937installs10MemorizeMemorize is a Claude Code skill from neolabhq/context-engineering-kit implementing Agentic Context Engineering memory consolidation. After reflections, debates, or verification outcomes, Memorize curates durable insights and organizes them into CLAUDE.md so future agent runs inherit lessons without re-discovering mistakes. It supports optional source selection from the last task, a selection, chat:id references, and --dry-run preview before writing. Developers reach for Memorize when agent sessions produce useful critiques, when CLAUDE.md has grown noisy, or when teams want a repeatable playbook that compounds context quality across sprints.935installs11Kaizenkaizen is a context-engineering-kit skill automatically applied during code implementation, refactoring, system design, workflow improvements, and error handling. It promotes many small improvements over large rewrites, error-proof designs, following established patterns, and building only what is needed. Developers reach for kaizen when agents tend toward over-engineering or big-bang refactors and need guardrails for iterative quality. The skill frames continuous improvement as a default mindset: suggest incremental fixes, validate inputs, reuse proven patterns, and reject unnecessary abstraction. It complements architecture skills by constraining scope during day-to-day coding sessions.934installs12Test Driven Developmenttest-driven-development is a discipline skill from neolabhq/context-engineering-kit with a strict red-green cycle: write the test first, watch it fail, then write minimal code to pass. The core principle states that if you did not watch the test fail, you cannot know whether it tests the right behavior. Developers apply test-driven-development for new features, bug fixes, refactoring, and behavior changes inside AI coding agents. Exceptions require explicit human approval for throwaway prototypes. The skill treats violating procedural rules as violating intent, preventing agents from skipping failure verification. It produces failing then passing test suites that prove behavioral coverage before merge.927installs13Root Cause Tracingroot-cause-tracing is part of the neolabhq context-engineering-kit and teaches agents to reject quick fixes at the failure site when bugs manifest deep in the stack. The workflow traces backward through the call chain—examples include git init in the wrong directory, files created in the wrong path, or databases opened with incorrect paths—adding instrumentation when visibility is missing. The core principle is to locate the original trigger and fix at the source rather than patching where the exception surfaces. Developers reach for root-cause-tracing when stack traces show downstream errors but the initiating call or bad input entered several layers earlier.926installs14Judge With DebateJudge-with-debate is a neolabhq context-engineering-kit skill implementing the Multi-Agent Debate pattern for solution evaluation. Multiple independent judges analyze proposals, challenge each other's reasoning with evidence, and refine assessments across rounds until consensus or a maximum round limit. Unlike single-pass reviews, debate forces judges to defend positions and surface blind spots in code, architecture, design, or strategy decisions. Developers reach for judge-with-debate when high-stakes evaluations—merge decisions, architecture choices, or design critiques—need bias-resistant consensus rather than one model's quick verdict. Invoke with solution paths and explicit evaluation criteria as arguments.923installs15Plan Taskplan-task is a neolabhq/context-engineering-kit skill that analyzes business requirements and rewrites task files with comprehensive, testable acceptance criteria. The workflow gathers all findings in a scratchpad first, then copies only verified details into the task file so vague prompts do not reach implementation. Developers and tech leads invoke plan-task when tickets lack measurable success conditions, scope boundaries, or verifiable outcomes that engineers can test. The skill explicitly warns that untestable criteria and incomplete scope cause rework, positioning the agent as accountable for specification quality before any code changes.922installs16Write Conciselywrite-concisely is a context-engineering-kit skill grounded in William Strunk Jr.'s The Elements of Style (1918) and applies elementary usage, punctuation, and concision rules to any documentation task a user requests. It targets README files, technical documentation, and user-facing copy that must read clearly under professional standards. The workflow cuts redundancy, strengthens sentences, and enforces grammar and punctuation conventions without changing the underlying technical facts. Developers reach for write-concisely when drafts are accurate but wordy, when AI-generated docs need a human polish pass, or before publishing externally visible text.913installs17Agent Evaluationagent-evaluation is a context-engineering-kit skill from neolabhq that builds evaluation frameworks for Claude Code commands, skills, and autonomous agents where outputs are non-deterministic and lack single correct answers. The skill addresses dynamic agent decisions, run-to-run variance, and subjective quality by defining scoring rubrics, regression checks, and actionable feedback loops for prompt and context changes. Developers reach for agent-evaluation when a new skill misfires across sessions, when prompt tweaks need measurable before-and-after comparison, or when validating that context engineering choices actually improve agent reliability rather than guessing from anecdotal runs.904installs18Do In Paralleldo-in-parallel is a Claude Code skill from neolabhq/context-engineering-kit that runs independent tasks concurrently across multiple files or targets using parallel sub-agents. The skill analyzes work to select optimal models—opus, sonnet, or haiku—per task, groups requirements as repeatable, shared, or independent, and applies LLM-as-a-judge verification on outputs. Developers reach for do-in-parallel when batch refactors, multi-file analysis, or parallel code generation would be slow if executed sequentially in one agent thread. Argument hints support task descriptions with --files, --targets, --model, and --output path flags for structured invocation. Agents generate quality-focused prompts for each sub-agent, making the skill suited to large codebases where tasks do not depend on each other's intermediate results. The skill improves throughput during build-phase agent-tooling without replacing workflows that require strict ordering or shared mutable state across steps.904installs19Implement Taskimplement-task is a neolabhq context-engineering-kit skill that executes a task specification file end to end without stopping until steps pass automated quality gates. The workflow launches a developer agent, runs the sdd:code-reviewer sub-agent on each critical artifact, iterates until issues clear, then advances to the next step. CLI modes include --continue for resuming partial runs and --human-in-the-loop for gated approvals, accepting arguments like add-validation.feature.md. Developers reach for implement-task when a feature spec already exists as a markdown task file and they want sub-agent orchestration with LLM-as-Judge verification per step instead of a single monolithic codegen pass that skips structured review.904installs20Do In Stepsdo-in-steps is a sequential sub-agent orchestration skill from neolabhq/context-engineering-kit that decomposes complex tasks into dependent steps executed in order. Each step runs through a dedicated sub-agent with automatically selected models, receives context from completed prior steps, and must pass independent LLM-as-a-judge verification before the next step begins. Developers reach for do-in-steps when refactoring a service class and updating all consumers, or any task where step N depends on the output of step N-1. The skill analyzes task dependencies automatically and halts the pipeline if a verification gate fails.903installs21Add Taskadd-task is a skill from neolabhq/context-engineering-kit that converts a raw idea or feature request into a draft task file under .specs/tasks/draft/. Each file gets an action-oriented title, type classification (feature, bug, refactor, test, docs, chore, or ci), optional dependency links to other task files, and a description preserving original user intent. Invoke it with a task title or description plus optional dependency list. The skill standardizes how agents and teams capture work before refinement or implementation. Reach for add-task when a feature request arrives unstructured and must land in the project's spec-driven task system immediately.902installs22Analyseanalyse is a context-engineering-kit skill that intelligently picks the best Kaizen method for a given target. Gemba Walk suits code exploration, Value Stream Mapping fits workflows and processes, and Muda Analysis targets waste identification. Invoke with /analyse plus an optional target such as authentication implementation, deployment workflow, or codebase inefficiencies. The skill guides the selected technique end to end instead of forcing one fixed framework. Reach for analyse when improvement work needs the right lean analysis method chosen from context rather than a generic code review or A3 problem write-up.897installs23Review Local Changesreview-local-changes is a context-engineering-kit skill from neolabhq that conducts systematic reviews of local uncommitted working-tree changes including git diff output and untracked files before anything is pushed. Developers optionally filter by review aspects and minimum impact levels from critical down to low, with JSON output for automation pipelines. The skill skips spec/ and reports/ folders by default unless explicitly requested, keeping reviews focused on application code. Engineering teams reach for review-local-changes when they want high-signal feedback with concrete fix suggestions immediately before git commit or PR creation, catching design and quality issues while changes remain easy to amend locally.897installs24Analyse Problemanalyse-problem is a context-engineering-kit skill applying the A3 problem-solving format for single-page documentation. Each A3 covers Background, Current Condition, Goal, Root Cause Analysis, Countermeasures, Implementation Plan, and Follow-up—named for A3 paper size emphasizing concise completeness. Invoke with /analyse-problem and an optional problem description; output can be markdown or other configured formats. Use analyse-problem when a recurring issue needs root-cause clarity and an action plan before sprint commitment. Pair with analyse for choosing Kaizen techniques and add-task for turning countermeasures into draft spec tasks.895installs25Launch Sub Agentlaunch-sub-agent is a context-engineering-kit skill from neolabhq that analyzes a task description, picks an optimal model and specialized agent configuration, and dispatches a sub-agent with Zero-shot CoT at the start and mandatory self-critique at the end. Developers pass tasks like implementing authentication or researching caching strategies, with optional flags for opus, sonnet, or haiku models, named agents, and output paths. Engineering teams reach for launch-sub-agent when a parent agent session needs a clean, isolated worker for a bounded subtask without polluting the main context window. The skill automates model-to-complexity matching and enforces verification before returning sub-agent output to the orchestrating session.894installs26Setup Serena Mcpsetup-serena-mcp is an MCP integration skill from neolabhq/context-engineering-kit that walks developers through configuring the Serena MCP server for semantic code retrieval and precise editing. The skill offers two setup paths: project-level configuration shared via git with CLAUDE.md updates, or personal preferences stored locally in CLAUDE.local.md excluded from version control. Developers reach for setup-serena-mcp when onboarding Serena MCP to a new project or standardizing semantic code tools across a team. The skill determines setup context based on user preferences and client type before writing configuration.892installs27Whywhy is a skill from neolabhq/context-engineering-kit that applies Five Whys root cause analysis to engineering and product issues. Invoked as `/why [issue_description]`, the skill states the problem, asks repeated why questions with configurable depth defaulting to 5 iterations, and moves from surface symptoms to fundamental causes. It targets bugs, failed deployments, user complaints, and stalled growth where quick fixes hide systemic problems. Developers and on-call engineers reach for why during postmortems, recurring incidents, or persistent quality issues requiring structured causal chains.892installs28Write Testswrite-tests is a skill in neolabhq/context-engineering-kit that adds missing test coverage for local code changes by generating new test files. It inspects the current git diff for uncommitted and untracked changes by default, or covers the latest commit when the working tree is clean. Developers can pass optional arguments to focus on specific modules or test types. The skill deliberately avoids rewriting existing tests, targeting only new logic introduced in recent edits. Teams reach for write-tests immediately after implementing features or refactors when coverage gaps block PR review. write-tests fits agent-assisted TDD follow-through where the implementation landed first and tests still need to catch up.892installs29Create Ideascreate-ideas is a context-engineering-kit skill that generates ideas in one shot using creative sampling. For each query, it produces six separate responses as list items, each with descriptive text and a numeric probability. The first three responses target high-probability solutions above 0.80; the last three explore diverse tail regions of the solution space with probabilities below that threshold. Developers reach for create-ideas at the start of feature planning, architecture debates, or bug-fix strategy sessions when a single LLM answer feels too narrow. An optional argument hint accepts a topic and desired idea count. The skill favors exploration over convergence—useful before PRDs, spikes, or design docs lock one path.890installs30Fix Testsfix-tests is a context-engineering-kit command skill that systematically repairs failing tests after business-logic changes, refactors, or dependency upgrades. The skill accepts optional module or test focus arguments and otherwise targets the full failing suite, coordinating specialized agents to align assertions and fixtures with current implementation. Developers reach for fix-tests when CI turns red after intentional code changes but production behavior should remain unchanged. Important constraints keep the pass focused on test repair rather than silent product-logic rewrites, making it suitable post-refactor stabilization. The workflow orchestrates automated fixing across failing cases until the suite matches present business rules and implementation details.890installs31Do And Judgedo-and-judge is a command skill from neolabhq/context-engineering-kit that executes a single task by dispatching an implementation sub-agent and verifying output with an independent LLM-as-judge, looping with feedback until passing or max retries are exceeded. The orchestrator dispatches a meta-judge to generate evaluation criteria and the implementation agent in parallel, then iterates on judge feedback. Developers reach for do-and-judge when delegating focused engineering work—such as refactoring a UserService to dependency injection—where autonomous implementation must be quality-checked before merge. The pattern pairs meta-judge rubric creation with retry loops, reducing silent failures from unchecked sub-agent output.886installs32Commitcommit is a Claude Code command skill from neolabhq/context-engineering-kit that automates well-formatted git commits with conventional commit messages and emoji. Configured to run on the haiku model, the skill uses allowed Bash tools for git status, add, diff, commit, branch, and checkout plus package-manager lint commands across pnpm, npm, yarn, and bun. Developers reach for commit when they want agents to inspect staged and unstaged changes, avoid messy monolithic commits, and produce readable conventional messages instead of vague summaries. Instructions require a branch check that warns on master or main, asks before committing on protected branches, and follows a strict step sequence for staging and message formatting. Optional argument hints include flags like --no-verify to skip pre-commit checks when explicitly requested. The skill delivers commit-ready git history hygiene during day-to-day ship and review workflows.885installs33Judgejudge implements a two-phase meta-judge then LLM-as-judge pipeline from the context-engineering-kit to assess work produced earlier in a conversation. A meta-judge first generates tailored evaluation criteria; a judge sub-agent then applies those criteria with isolated context, structured scoring, and evidence-based feedback. Findings are report-only—no automatic repo edits. Developers invoke judge when they want an objective post-task audit of agent output, plans, or implementations with optional evaluation-focus arguments.885installs34Create RuleCreate Rule is an agent-behavior skill from neolabhq/context-engineering-kit for authoring effective .claude/rules files that load into every session and shape how agents behave across all tasks. The skill distinguishes rules—which are permanent behavioral guardrails—from skills that load on demand. Its core principle requires contrastive examples showing Incorrect versus Correct patterns to eliminate ambiguity when an agent or implementation pass repeats the same mistake. Developers invoke Create Rule when they recognize a gap such as saying You absolutely right, I should have done it differently and want a durable fix. Create Rule produces session-persistent guidance that prevents recurring errors in formatting, architecture choices, or workflow conventions without re-explaining context each time.883installs35Create Skillcreate-skill is a command skill from neolabhq/context-engineering-kit that guides developers through creating effective agent skills extending Claude or Codex with specialized knowledge, workflows, or tool integrations. It treats writing skills as Test-Driven Development applied to process documentation: test with subagents before writing, iterate until bulletproof against rationalization, and verify skills work before deployment. Developers reach for create-skill when authoring new skills, editing existing SKILL.md files, or validating agent capabilities before shipping them to a team or marketplace. The guide covers personal and shared skill patterns, deployment verification, and iterative refinement against subagent test runs rather than one-shot documentation drafts.882installs36Tree Of Thoughtstree-of-thoughts is a Claude Code skill from neolabhq/context-engineering-kit that applies the Tree of Thoughts (ToT) pattern to complex reasoning tasks. It systematically samples solution branches, prunes unpromising paths, expands viable approaches, and synthesizes a final answer using meta-judge evaluation specifications and multi-agent evaluation. Developers reach for tree-of-thoughts when a single-shot prompt risks wrong architecture, ambiguous trade-offs, or tasks requiring deliberate exploration of the solution space before full implementation. The skill accepts a task description plus optional output path and evaluation criteria, making it suited to refactors, design decisions, and multi-step engineering problems where premature commitment is costly.882installs37Do Competitivelydo-competitively is a skill from neolabhq/context-engineering-kit implementing the Generate-Critique-Synthesize (GCS) pattern with adaptive strategy selection for high-stakes tasks where quality outweighs speed. The workflow runs competitive multi-agent generation in parallel, defines a meta-judge evaluation specification, applies multi-judge evaluation across candidate outputs, and synthesizes the best elements into a final deliverable based on evidence. Developers reach for do-competitively when a single agent pass risks shallow or inconsistent results on complex coding, architecture, or specification tasks. The skill accepts a task description with optional output path and evaluation criteria, making it a structured quality gate for agent orchestration.880installs38Test Prompttest-prompt is an agent skill from neolabhq/context-engineering-kit that treats prompt engineering as test-driven development. It validates commands, hooks, skills, subagent instructions, and production LLM prompts by running scenarios without the prompt (RED), writing instructions that fix failures (GREEN), and closing loopholes (REFACTOR) using subagents for isolated testing. The core principle is that prompt quality cannot be assumed without observed agent behavior. Developers reach for it whenever they author or edit agent instructions and need evidence that subagents comply under realistic scenarios, not just polished prose. It fits teams shipping Claude Code commands, Cursor hooks, or multi-agent workflows who want repeatable verification instead of one-off manual chats.878installs39Test Skilltest-skill is a context-engineering-kit skill for verifying agent skills under pressure before they ship. The workflow treats skill documentation like code under test: run scenarios without the skill (RED), author skill guidance that fixes observed failures (GREEN), then refactor to close rationalization loopholes (REFACTOR). Developers reach for test-skill when creating or editing skills and need evidence that agents comply instead of drifting when stressed. Subagents execute baseline and skill-enabled runs so authors watch real failure modes rather than assuming prose works. The core principle is that untested process documentation is unreliable; test-skill makes skill quality measurable before deployment to Claude Code, Cursor, or similar agents.878installs40Analyze Issueanalyze-issue is a skill from neolabhq/context-engineering-kit that accepts a GitHub issue number as an argument and produces a detailed technical specification. The workflow checks ./specs/issues/ for an existing file matching the pattern number-padded-to-3-digits-kebab-case-title.md, fetches missing issues via gh issue commands following load-issues.md instructions, then writes a spec covering implementation steps, a test plan, and proposed file changes. Developers reach for analyze-issue when a GitHub ticket is too vague for direct coding and needs structured decomposition before sprint work. Allowed tools include Bash(gh issue:*), Read, Write, Glob, and Grep, making it a git-integrated planning step in context-engineering workflows.875installs41Apply Anthropic Skill Best Practicesapply-anthropic-skill-best-practices is a skill from neolabhq/context-engineering-kit that applies Anthropic's official skill authoring guidance to skills under development or review. It targets complex skills needing deliberate metadata, concise structure, and validation through real usage—the kit stresses that good skills are discoverable, well-structured, and tested rather than token-heavy prompt dumps. The skill accepts an optional skill name or path via argument-hint for focused reviews. Core principles cover skill metadata costs at startup, practical authoring decisions, and structural patterns Claude can invoke consistently. Developers reach for it when a custom skill misfires, overlaps other skills, or fails discovery in Claude Code sessions. Use it as a checklist pass before publishing skills to a team registry or MCP-adjacent workflow library.873installs42Actualizeactualize is a skill from neolabhq/context-engineering-kit that keeps an FPF (Formal Product Framework) knowledge base synchronized with the evolving codebase. The command performs a three-part audit against recent git changes to surface context drift, stale evidence, and outdated decisions stored under `.fpf/`. It aligns with the Observe phase of the FPF Canonical Evolution Loop and helps manage Epistemic Debt called out in the kit documentation. Developers run actualize when architectural decisions, assurance claims, or evidence links may no longer match merged commits. Step one checks git changes since the last actualization, then compares repository reality against recorded FPF state. Reach for actualize during ongoing iteration—not at greenfield setup—when living documentation must stay trustworthy for agents and reviewers.872installs43Review Prreview-pr is a skill in neolabhq/context-engineering-kit that conducts systematic expert review of an existing GitHub pull request and posts inline comments on the diff only—no overall review summary posts. Developers pass optional review-aspects and --min-impact levels from critical through low to filter noise. The skill skips spec/ and reports/ folders unless explicitly requested. It targets opened PRs on GitHub rather than uncommitted local changes. Invoke review-pr when a PR is already open and you need actionable inline feedback posted directly on changed lines with impact-tier control.870installs44Plan Do Check Actplan-do-check-act from neolabhq/context-engineering-kit implements a four-phase PDCA cycle—Plan (identify and analyze), Do (implement changes), Check (measure results), Act (standardize or adjust)—for iterative problem solving. Invoke it with `/plan-do-check-act [improvement_goal]` where GOAL targets a specific problem and CYCLE_NUMBER tracks iteration count. Developers reach for this skill when agent-assisted work needs repeatable experimentation loops instead of one-shot fixes, such as tuning build pipelines, refining agent prompts, or optimizing review workflows. Each cycle ends by either standardizing successful changes or feeding learnings into the next plan phase.869installs45Cause And Effectcause-and-effect is a skill from neolabhq/context-engineering-kit that applies Fishbone (Ishikawa) diagram analysis to map potential causes of a stated problem. The skill systematically examines six categories—People, Process, Technology, Environment, Methods, and Materials—and produces a structured fishbone view of contributing factors. Invoke it with /cause-and-effect and an optional problem description, or let the agent prompt for PROBLEM input. Developers reach for cause-and-effect when postmortems, defect triage, or quality regressions need breadth-first cause exploration instead of jumping to a single hypothesis.865installs46Create Prcreate-pr from neolabhq/context-engineering-kit guides agents through draft GitHub pull request creation using `gh pr` commands after the branch is committed and pushed. Allowed tools include `gh pr:*`, `gh auth:*`, `git status`, `git push`, `git branch`, and the `git:commit` skill dependency. PR titles and descriptions must be written in English, and the workflow checks for `gh` installation with brew-based setup instructions for macOS. Developers reach for create-pr when an agent session finishes feature work and needs a templated, consistently formatted draft PR instead of manual GitHub UI steps. It assumes GitHub CLI authentication is available.864installs47Attach Review To Prattach-review-to-pr is a skill from neolabhq/context-engineering-kit that teaches coding agents how to add line-specific review comments to GitHub pull requests, mirroring the GitHub UI diff-comment workflow. The preferred path uses mcp__github_inline_comment__create_inline_comment when available; otherwise it falls back to gh api, gh auth, and gh pr commands declared in allowed-tools. Developers reach for attach-review-to-pr when an agent has review findings and must publish them on exact file lines of an open PR instead of dumping a generic summary. The skill accepts an optional PR number or URL and can work from the current branch.856installs48Create Agentcreate-agent is a command skill in neolabhq/context-engineering-kit that scaffolds Claude Code agents with YAML frontmatter, triggering conditions, system prompts, and validation based on Anthropic documentation and proven patterns. It accepts an agent name and optional purpose description, then guides creation of autonomous subprocess agents that handle complex multi-step tasks independently. Allowed tools include Read, Write, Glob, Grep, Bash for mkdir, and Task delegation. Developers reach for create-agent when spinning up a new specialized subagent instead of hand-writing frontmatter, trigger rules, and validation from scratch.856installs49Create Hookcreate-hook is a git automation skill from neolabhq/context-engineering-kit that inspects project tooling, recommends relevant hooks, configures scripts, and validates they run correctly. Its workflow has four steps: analyze the environment, suggest hooks based on detected tools, configure the hook after targeted questions, then test and validate execution. Developers use create-hook when they need pre-commit or pre-push guards for linters, formatters, tests, or custom policies without hand-writing brittle shell scripts. The skill fits repos adopting Husky, plain .git/hooks, or framework-specific hook runners after cloning or restructuring CI boundaries.855installs50Propose Hypothesespropose-hypotheses is a context-engineering-kit skill that runs the complete First Principles Framework (FPF) cycle from a single problem-statement argument. The workflow creates a `.fpf/` directory tree with `evidence`, `decisions`, `sessions`, and `knowledge` layers including L0, L1, L2, and invalid buckets, then generates competing hypotheses, verifies logic, validates evidence, audits trust, and records a decision. Developers reach for propose-hypotheses when architectural or product choices are underspecified and need documented reasoning rather than gut calls. The skill uses Task, Read, Write, Bash, and AskUserQuestion tools, making it suited to agent-led discovery sessions that must leave auditable artifacts behind.855installs51Create Commandcreate-command is a Command Creator Assistant in the context-engineering-kit that helps developers author new Claude commands with correct structure, patterns, and MCP tool integration. The workflow reads the command creation guide at docs/claude-commands-guide.md, understands the command purpose from an optional name or description argument, determines category and pattern, and outputs Scopecraft-conformant command definitions. Developers reach for create-command when expanding agent tooling with repeatable slash commands instead of ad hoc prompts. The skill acts as a meta-command—creating other commands—so it fits teams standardizing Claude Code or Cursor command libraries with consistent frontmatter, argument hints, and allowed-tools declarations.853installs52Git Worktreesgit-worktrees is a context-engineering-kit skill documenting git worktree workflows for parallel development with multiple working directories sharing one repository. The core principle is one worktree per active branch: switch contexts by changing directories, not branches. Developers reach for git-worktrees when working on multiple branches simultaneously, reviewing PRs while developing, testing in isolation, or comparing implementations across branches without stashing changes or cloning the repo again. The skill supplies git worktree commands and patterns for creating, listing, and removing worktrees, making it a reference workflow for teams using Claude Code or Cursor during concurrent feature and review cycles.853installs53Load Issuesload-issues is a context-engineering-kit skill that automates GitHub issue export for agent-assisted planning. The workflow runs `gh issue list --limit 100`, then fetches each open issue with `gh issue view` JSON fields including number, title, body, state, labels, assignees, author, and URL. Each issue is saved as a markdown file in `./specs/issues/`, giving developers a local, searchable spec corpus without manual copy-paste. Reach for load-issues when you want Claude or another coding agent to triage backlog items, draft implementation plans, or cross-reference open work against in-repo specs. The skill requires Bash access for `gh issue:*`, `mkdir`, and Write permissions, and assumes the current directory is a GitHub repository with gh authenticated.851installs54Build Mcpbuild-mcp is a Claude Code skill from neolabhq/context-engineering-kit that teaches workflow-first MCP server development for integrating external APIs and services with LLMs. The guide covers Python via FastMCP and Node or TypeScript via the MCP SDK, emphasizing tool design quality measured by how well agents accomplish real tasks. Developers reach for build-mcp when standing up a new MCP integration rather than ad hoc prompt wrappers or oversized single tools. The skill focuses on structuring tools for agent success, not just exposing raw REST endpoints. It fits teams embedding MCP into Claude Code, Cursor, or other MCP-compatible agents. Use build-mcp during server scaffolding, tool granularity decisions, and API surface design before shipping an integration to production agent configs.850installs55Setup Codemap Clisetup-codemap-cli from neolabhq context-engineering-kit guides installation and configuration of Codemap CLI for intelligent codebase visualization and navigation inside agent workflows. The skill first determines whether configuration lives at project level shared via git—updating ./CLAUDE.md and ./.claude/settings.json—or as personal preferences in ./CLAUDE.local.md untracked locally. Developers reach for setup-codemap-cli when agents struggle to orient in monorepos or large services and need Codemap-driven maps plus hook integration so Claude Code can reason over structure instead of blind file grepping. Optional argument hints capture OS type and configuration preferences, producing agent-ready Codemap wiring rather than manual trial-and-error CLI setup.849installs56Decaydecay is a skill in neolabhq/context-engineering-kit that implements FPF B.3.4 Evidence Decay for decision-record governance. Every evidence item carries a valid_until date; when benchmarks, security audits, or performance measurements expire, linked decisions inherit hidden risk until evidence is refreshed or superseded. The skill scans decision artifacts for stale supporting evidence and outputs governance actions such as re-benchmarking, re-auditing, or formally accepting residual risk. A benchmark from six months ago may no longer reflect current system performance, and a security audit completed before a major dependency upgrade cannot account for newly introduced vulnerabilities. Developers reach for decay when ADRs, launch checklists, or ops runbooks still cite outdated load tests or expired compliance proof. It complements context-engineering workflows that treat evidence as perishable rather than permanent justification for ship and operate choices across the software lifecycle.848installs57Queryquery is a neolabhq/context-engineering-kit skill for searching the FPF knowledge base at run time. It scans .fpf/knowledge and .fpf/decisions, then presents hypothesis title, layer (L0/L1/L2), kind, scope, audit R_eff for L1+, dependency graphs, and evidence summaries in table format. Developers reach for query when they need verified hypotheses, decision records, or assurance information while building or iterating on complex systems without manually grepping markdown knowledge files.848installs58Resetreset is a runtime skill from neolabhq/context-engineering-kit that restarts the FPF (First-Principles Framework) reasoning cycle. Its soft-reset path creates a dated session archive under .fpf/sessions/ recording hypotheses at L0 proposed, L1 verified, and L2 validated counts, reset reason, and ISO timestamps, then clears active hypothesis work. Developers reach for reset when an FPF session stalls, hypotheses conflict, or the user requests a clean slate while preserving auditable session history on disk. The archive file uses YAML frontmatter with id, action, created, and reason fields so later reviews can reconstruct state at abandonment. reset is intentionally narrow—archive, clear, restart—making it the operational counterpart to hypothesis-building skills in the same context-engineering-kit. Unlike deleting .fpf data, soft reset preserves completed or abandoned reasoning trails for postmortems. Agents invoke reset at user request or when cyclical FPF work needs a documented fresh start without losing institutional memory from prior sessions.848installs59Statusstatus is a Claude Code skill from neolabhq/context-engineering-kit that displays the current state of the FPF (`.fpf/`) knowledge base at runtime. The skill verifies `.fpf/` directory structure, counts hypothesis files across four knowledge layers—L0 Proposed, L1 Verified, L2 Validated, and invalid Rejected—scans `.fpf/evidence/` for expired evidence, and lists decision files under `.fpf/decisions/`. Developers reach for status before continuing context-engineering work when they need a ground-truth snapshot of what is proposed, verified, validated, or rejected. Output follows a structured markdown status report format defined in the skill. status is a read-only health check, not a hypothesis authoring or evidence ingestion tool.846installs60Setup Arxiv Mcpsetup-arxiv-mcp is a Claude Code skill from neolabhq/context-engineering-kit for deploying the arXiv paper search MCP server using Docker MCP. The guide first asks whether configuration should live in git-tracked ./CLAUDE.md for shared project setup or ./CLAUDE.local.md for personal preferences, and verifies ignore rules accordingly. Developers reach for setup-arxiv-mcp when they want agents to query arXiv papers without manually crafting MCP JSON or Docker commands each time. Optional argument hints allow narrowing research topics or paper sources during setup. The skill is a setup walkthrough, not a paper summarization or citation formatter. It pairs with broader context-engineering workflows where literature search feeds hypothesis work inside agent sessions.845installs61Create Workflow Commandcreate-workflow-command is a neolabhq/context-engineering-kit skill for building workflow commands that orchestrate multi-step agent execution. It accepts a workflow name and description, then scaffolds commands that dispatch sub-agents while storing detailed step instructions in separate files to solve context bloat in the orchestrator. Allowed tools include Read, Write, Glob, Grep, and Bash mkdir. Developers reach for create-workflow-command when turning repeatable natural-language procedures into structured, file-backed agent workflows.844installs62Setup Context7 Mcpsetup-context7-mcp is a setup guide from neolabhq/context-engineering-kit for wiring the Context7 MCP server into Claude Code or compatible agents. The skill walks through choosing project-level git-tracked config in CLAUDE.md versus local-only CLAUDE.local.md, then registers Context7 so agents can fetch structured docs for user-specified languages and frameworks via argument hints. Developers reach for setup-context7-mcp when onboarding Context7 to a repo, standardizing team documentation access, or replacing ad-hoc doc pasting with MCP-backed retrieval during implementation work.841installs63Git NotesGit Notes is a context-engineering-kit skill for attaching metadata to Git commits and objects without modifying the objects themselves. Notes live in a separate notes ref and display alongside commit messages, following the core principle of adding information after commit creation without history rewrites. The skill covers git notes commands and patterns for tracking review status, test results, code-quality annotations, and supplemental commit context. Developers reach for Git Notes when LLM agents or teammates need richer per-commit signals in repositories fed to Claude, Cursor, or Codex—improving context quality without force-pushing amended commits.833installs64Git:Worktreesgit:worktrees is a skill from neolabhq/context-engineering-kit for maintaining clean, isolated Git worktrees during agent-assisted development. It helps developers spin up separate working directories bound to individual branches or features so large language model context stays scoped to one change set at a time. The skill addresses a common failure mode where agents mix files, configs, or diffs from multiple active branches in a single workspace. Developers reach for git:worktrees when running parallel features, experimenting on side branches, or keeping the main checkout pristine while agents edit code elsewhere. It pairs with context-engineering practices that treat workspace isolation as a first-class requirement for reliable autonomous coding sessions.453installs65Git:Notesgit:notes is a skill in neolabhq/context-engineering-kit that teaches agents and humans to attach metadata to Git commits using git notes instead of amending history. Notes preserve the original commit SHA while storing review approvals, test results, audit trails, agent handoff context, and decision records after the commit lands. The skill covers namespace management to separate review notes from testing notes, push and fetch workflows because notes do not sync automatically, configuration to preserve notes during rebases, and the append versus add distinction when updating existing note objects. Developers reach for git:notes when compliance or agent workflows need post-commit annotations, cross-session repo memory, or handoff notes that should travel with specific commits rather than living only in chat logs. It complements other Context Engineering Kit git commands for commits and pull requests by adding non-invasive metadata layers on top of standard Git history.409installs66Design Testing Strategydesign-testing-strategy is a Claude Code skill for testing & qa. It helps solo builders move faster with AI-assisted development.305installs67Test Coveragetest-coverage is a Claude Code skill for testing & qa. It helps solo builders move faster with AI-assisted development.295installs68Software ArchitectureFramework for thinking through and documenting software architecture decisions. Helps solo builders articulate system design, identify constraints, evaluate trade-offs, and keep architectural thinking visible during code review and agent-assisted development.40installs69WorktreesGuide and automation for using git worktrees to manage multiple independent branches in a single repo. Solo builders use this to test features, bug fixes, and experiments in isolation without repeatedly checking out different branches.20installs70NotesSkill for managing project notes and context that travels with your codebase and agent interactions. Helps solo builders maintain a living record of design decisions, architectural notes, and context that agent tools can read and reference during collaboration.17installs