stub-engine

Map exported functions, context reads/writes, and dependencies across engine phase files.

1|Updated Jan 15, 2026
One-click install
npx skills add https://github.com/pnils08/GodWorld --skill stub-engine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: stub-engine
Source: https://github.com/pnils08/GodWorld/tree/main/.claude/skills/stub-engine
Command: npx skills add https://github.com/pnils08/GodWorld --skill stub-engine

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The Skill produces a condensed, comprehensive map of every exported function across all engine phases, detailing which context fields are read and written, and highlighting dependencies for quick comprehension and maintenance.

Core Features & Use Cases

  • Phase-wide function map: lists all exported functions, their parameters, and where they are defined.
  • Context touchpoints: documents ctx.summary.* reads and writes to reveal data flow.
  • Dependency insights: shows inter-function calls and sheet references to aid debugging and onboarding.
  • Use Case: when starting a cold session or performing a codebase audit, generate a concise reference to orient engineers quickly.

Quick Start

Run the stub-engine skill after code compaction to generate the current engine function map.

Frequently Asked Questions about stub-engine

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

FAQPage Schema
How do I map engine functions across all phases for debugging?

Engine function mapping works by listing all exported functions, their parameters, context field reads and writes, and sheet references across all phase files to reveal execution order and inter-function dependencies.

What is the best way to document context reads and writes across engine phases?

The best way to trace context data flow is to generate a function map that documents ctx.summary.* reads and writes alongside sheet references, revealing how data moves across engine phases.

How do I trace inter-function dependencies in a multi-phase engine codebase?

Tracing inter-function dependencies requires analyzing calls and exports across phase files to infer execution order and identify which functions rely on others within the engine.

Can I use a code map to onboard engineers to a complex engine codebase?

A code map supports onboarding by providing a concise reference of exported functions, their parameters, and context touchpoints across all phases, helping new engineers quickly comprehend execution flow and data dependencies.

Does this function mapping process work without external dependencies?

Yes, function mapping operates with no external dependencies, analyzing only the engine's internal phase files and utilities to produce the comprehensive function and context reference map.

When should I generate an engine function map?

Generate an engine function map during cold sessions or codebase audits to quickly orient yourself, and after code compaction to ensure the current function, context, and dependency reference is up to date.