pstack-engineering

Resolves delivery bottlenecks caused by ambiguity, repeated investigation, handoff drift, and shared-state contention.

Updated Jun 28, 2026
One-click install
npx skills add https://github.com/AO-HyS/aohys.com --skill pstack-engineering-ao-hys
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: pstack-engineering
Source: https://github.com/AO-HyS/aohys.com/tree/main/.agents/skills/pstack-engineering
Command: npx skills add https://github.com/AO-HyS/aohys.com --skill pstack-engineering-ao-hys

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Software delivery stalls when intent is ambiguous, investigations repeat, handoffs lose decisions, or multiple agents contend over shared state. This Skill provides a tactics reference for diagnosing and resolving those bottlenecks so work proceeds with clear ownership and preserved decisions. ## Core Features & Use Cases - Ambiguity Resolution: Restate the problem and observable outcome, recover prior decisions with source pointers, and use the smallest executable prototype to settle consequential unknowns. - Structured Handoffs: Handoffs carry root/revision, decisions, exclusions, ownership, known state, checks, and completion so resumed work reuses the decision record instead of rebuilding it from transcripts. - Ownership and Parallelization: Keep one accountable owner per coupled change and parallelize only independently verifiable work. - Use Case: When resuming a stalled feature after a context reset, read the handoff record to recover decisions and exclusions verbatim, then continue implementation without re-investigating settled questions. ## Quick Start Ask the agent to diagnose the current delivery bottleneck using the pstack-engineering tactics and apply the matching tactic from its references.

Frequently Asked Questions about pstack-engineering

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

FAQPage Schema
How do I resolve ambiguity in a software delivery task?▼

Restate the problem and the observable outcome briefly, then recover relevant prior decisions with source pointers. If a consequential unknown remains, build the smallest executable prototype that answers it, and stop exploring once the evidence supports an implementation.

How to structure a handoff between coding agents?▼

A handoff carries root/revision, decisions, exclusions, ownership, known state, checks, and completion status. On resume, reuse the decision record verbatim rather than rebuilding context from a long transcript, and update the record only after a real decision changes.

When should I use a prototype to resolve an unknown?▼

Use the smallest executable prototype when a consequential unknown is expected to reduce total delivery time by being resolved empirically. The prototype should answer a named question, then be discarded or integrated deliberately.

When should work be parallelized across agents?▼

Parallelize only independently verifiable work units. Keep one accountable owner for any coupled change or shared mutable state, and preserve evidence from stable units rather than recertifying the entire program after each change.

What practices from upstream PStack are not adopted?▼

Not adopted: mandatory architecture tournaments, competing implementations for ordinary edits, coordinator trees, fixed upstream model routing, autonomous external authority, and zero-diff pixel loops. These were excluded because they reintroduce observed overhead.