principle-foundational-thinking

Guides structural decisions on data structures, scaffolding order, and concurrency before writing logic.

136|8|Updated May 9, 2026
One-click install
npx skills add https://github.com/Sma1lboy/rove --skill principle-foundational-thinking-sma1lboy
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-foundational-thinking
Source: https://github.com/Sma1lboy/rove/tree/main/.agents/skills/pstack/skills/principle-foundational-thinking
Command: npx skills add https://github.com/Sma1lboy/rove --skill principle-foundational-thinking-sma1lboy

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers often jump into writing logic before settling core data structures, leading to premature abstractions, late-stage rewrites, and unsafe shared state. This Skill provides a decision framework to apply before coding so foundational choices keep options open. ## Core Features & Use Cases - Data-Structure-First Reasoning: Define core types early, trace access patterns, and match structures to dominant code paths. - Scaffold Sequencing: Order work so CI, linting, test infrastructure, and shared types land before features, keeping commits small and single-purpose. - Concurrency Check: Ask what happens when another actor modifies shared state, and isolate when the answer is not "nothing". - Use Case: Before implementing a new service module, use this Skill to decide the core data model, sequence test infrastructure ahead of features, and verify no shared mutable state crosses actor boundaries. ## Quick Start Apply the foundational thinking principles to review my planned data structures and work sequencing before I start implementing this feature.

Frequently Asked Questions about principle-foundational-thinking

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

FAQPage Schema
How do I choose the right data structure before writing code?▼

Define core types early and trace every access pattern, then pick structures matching the dominant paths. A data-structure change made early is often a one-line diff, while the same change late becomes a rewrite.

What work should be scaffolded before building features?▼

Scaffold anything that benefits every later phase: CI, linting, test infrastructure, and shared types. Sequence setup before features and tests before fixes, keeping commits small and single-purpose.

When is an abstraction premature in software design?▼

An abstraction is premature when three similar concrete statements would still be clearer. DRY the structure and data models rather than every line, and prefer explicit code over clever generalizations.

How do I decide if state is safe to share between concurrent actors?▼

Ask what happens if another actor modifies the state concurrently. If the answer is not "nothing", isolate the state instead of sharing it.

When should I remove code before adding new foundations?▼

Subtraction comes before scaffolding: remove dead weight first, then lay foundations. Each increment should land a coherent abstraction or deepen an existing one rather than spreading special-case coordination across callers.