hand-compute

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

40|1|Updated Apr 10, 2026

Search Tags:#debugging #trace #design-thinking #state-machine #race-condition #hand-compute #concrete-state

Ready to run

npx skills add https://github.com/gbasin/hand-compute --skill hand-compute

💬 Prompt for ChatGPT / Claude Chat▼

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.