hand-compute

Hand-compute system execution with explicit per-actor state at each step.

40|1|Updated Apr 10, 2026
One-click install
npx skills add https://github.com/gbasin/hand-compute --skill hand-compute
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: hand-compute
Source: https://github.com/gbasin/hand-compute/tree/main
Command: npx skills add https://github.com/gbasin/hand-compute --skill hand-compute

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Hand-computes system execution with explicit state at each step to surface state bugs and race conditions.

Core Features & Use Cases

  • Hand-compute with explicit per-actor state to reveal invariants and contradictions across transitions.
  • Supports three shapes (New work, Debugging, Scoping) with guidance to walk flows end-to-end and prevent narrative-only reasoning.
  • Ground transitions in actual code by referencing real functions and data structures, keeping the analysis in a single-head perspective.

Quick Start

Begin by choosing a task and walk the flow step by step, recording explicit state for every actor at each transition.

Frequently Asked Questions about hand-compute

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I debug race conditions in asynchronous interactions?

Debug race conditions by hand-computing system execution with explicit per-actor state at each step. Walking every transition manually surfaces state bugs and contradictions across asynchronous interactions.

What is the best way to trace state machine bugs across multiple actors?

Tracing state machine bugs requires hand-computing execution transitions while maintaining named objects for each actor. This concrete walk prevents narrative-only reasoning and reveals hidden invariant violations.

How do I scope features to catch state bugs early?

Scope features by walking end-to-end flows with concrete traces that reveal invariants. This single-head perspective analysis grounds transitions in actual code by referencing real functions and data structures.

Does hand-computing system state work without sub-agent fanout?

Yes, hand-computing system state explicitly requires keeping the walk within a single head to avoid sub-agent fanout. This constraint ensures accurate manual tracing of multi-actor flows without losing state context.

When should I manually walk system execution instead of using automated tracing?

Manually walk system execution when debugging multi-actor flows, asynchronous interactions, or feature scoping where concrete traces reveal invariants. Hand-computing exposes contradictions that automated traces often miss.