principle-foundational-thinking

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

4|1|Updated Dec 16, 2023
One-click install
npx skills add https://github.com/Shtian/AuthentiClash --skill principle-foundational-thinking-shtian
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: principle-foundational-thinking
Source: https://github.com/Shtian/AuthentiClash/tree/main/.claude/skills/principle-foundational-thinking
Command: npx skills add https://github.com/Shtian/AuthentiClash --skill principle-foundational-thinking-shtian

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases often accumulate premature abstractions, poorly chosen data structures, and unsafe shared state because structural decisions are made after logic is already written. This Skill provides a decision framework to apply before coding so downstream implementation 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 starting a new feature, apply this Skill to decide the core data model, sequence setup work ahead of feature work, and remove dead code before adding scaffolding. ## 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, trace every access pattern, and choose structures that match the dominant paths. Getting the data shape right first makes downstream logic obvious and avoids premature abstraction.

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

Build scaffold first: CI, linting, test infrastructure, and shared types, since every later phase benefits from them. Sequence setup before features and tests before fixes, keeping commits small and single-purpose.

When should I apply DRY versus keep code explicit?▼

DRY the structure, not every line: types and data models should converge, but three similar statements still beat a premature abstraction. Prefer explicit code over clever code and test behavior and edge cases, not line counts.

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

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 dead code instead of adding new structure?▼

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