principle-foundational-thinking

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

6.6k|542|Updated Jan 23, 2026
One-click install
npx skills add https://github.com/cursor/plugins --skill principle-foundational-thinking
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: principle-foundational-thinking
Source: https://github.com/cursor/plugins/tree/main/pstack/skills/principle-foundational-thinking
Command: npx skills add https://github.com/cursor/plugins --skill principle-foundational-thinking

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 concurrency bugs. This Skill provides a decision framework for making foundational choices early, when they are cheap to change.

Core Features & Use Cases

  • Data Structures First: Prompts you to define core types, trace access patterns, and choose structures matching dominant code paths before writing logic.
  • Scaffold Sequencing: Orders work so CI, linting, test infrastructure, and shared types land before features, keeping commits small and single-purpose.
  • Concurrency Check: Asks what happens when another actor modifies shared state, and isolates state when the answer is not "nothing".
  • Use Case: Before starting a new service, apply this Skill to decide the core data model, sequence scaffolding work, and identify shared-state risks so downstream code becomes obvious.

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 structures before writing code?

Define core types early, trace every access pattern, and choose structures that match the dominant paths. Getting the data shape right first makes downstream logic obvious, while a late data-structure change becomes a rewrite.

What is scaffold-first sequencing in software development?

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

When should I avoid creating an abstraction in code?

Avoid abstraction when it is premature: three similar statements still beat a wrong abstraction. DRY the structure and data models rather than every line, and prefer explicit code over cleverness.

How do I decide if shared state is safe under concurrency?

Ask what happens if another actor modifies the state concurrently. If the answer is not "nothing", isolate the state. This check should happen before sharing state between actors.

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.