principle-foundational-thinking

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

2|Updated Jun 27, 2026
One-click install
npx skills add https://github.com/imjasonh/playground --skill principle-foundational-thinking-imjasonh
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-foundational-thinking
Source: https://github.com/imjasonh/playground/tree/main/.cursor/skills/principle-foundational-thinking
Command: npx skills add https://github.com/imjasonh/playground --skill principle-foundational-thinking-imjasonh

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases often accumulate fragile abstractions and premature complexity because structural decisions are made reactively. This Skill provides a decision framework to apply before writing logic, so core types, data structures, and work sequencing are chosen deliberately and downstream code becomes obvious. ## Core Features & Use Cases - Data Structures First: Prompts you to define core types early, trace access patterns, and match structures to dominant code paths. - Scaffold Sequencing: Directs you to build CI, linting, test infrastructure, and shared types before features, keeping commits small and single-purpose. - Concurrency Corollary: Requires asking what happens when another actor modifies shared state, and isolating state when the answer is not "nothing". - Use Case: Before implementing a new service module, apply this Skill to decide the core data model, confirm test scaffolding exists, and verify no shared mutable state crosses actor boundaries. ## Quick Start Apply the foundational thinking principles to review my planned data model and work sequence 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 structures before writing code?▼

Define core types early and trace every access pattern the code will perform. Choose structures that match the dominant paths rather than optimizing for rare cases, and let types and data models converge instead of abstracting prematurely.

What should I build first when starting a new software project?▼

Build scaffolding first: CI, linting, test infrastructure, and shared types. Anything that benefits every later phase should come first, and each commit should stay small and single-purpose.

When should I avoid creating an abstraction in code?▼

Avoid abstraction when you only have three similar statements; concrete repetition beats premature abstraction. DRY the structure and data models, not every line, and prefer explicit code over clever code.

How do I decide if state can be shared between concurrent actors?▼

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

Should I remove dead code before adding new scaffolding?▼

Yes, subtraction comes before scaffolding. Remove dead code first so new foundations are laid on a clean base rather than around obsolete structures.