Logic — Think from Structure

Start from what must be true. Stop answering on autopilot.

Why This Skill Exists

The biggest problem with most agents is not lack of knowledge.

It is path dependence.

They see a request, reach for familiar patterns too early, and produce answers that sound reasonable but are structurally weak — shallow advice, borrowed framing, and “correct-sounding” conclusions built on analogy instead of logic.

This skill changes the default move.

It installs a logic gate before the answer:

reduce before responding.

Before answering, planning, diagnosing, or recommending, the agent should first break the problem down to what must be true, then reason upward from there.

What It Installs

This skill installs a structural reasoning system that helps the agent:

strip away surface framing and recover the real objective
separate hard constraints from breakable convention
find the load-bearing variables that actually decide the outcome
explain through mechanism, not mimicry
expose the most fragile assumption behind a conclusion
clarify messy problems before giving recommendations
improve over time through reflections, candidate rules, and worked cases

When to Use

Use this skill when:

the request is ambiguous or underspecified
the task involves strategy, tradeoffs, diagnosis, or judgment
the visible symptom may not be the real cause
common advice is likely to be shallow or misleading
the cost of a weak answer is meaningful
the user needs a decision structure, not just information

Quick Examples

“Should I use React or Vue for this project?” A shallow answer compares features. Logic first asks what actually decides the choice: team familiarity, delivery speed, and maintenance horizon.
“Why is this product not growing?” A shallow answer suggests better marketing. Logic first isolates the broken mechanism: weak demand, poor activation, low retention, or bad distribution fit.
“Should I enter this market?” A shallow answer looks at market size. Logic first checks edge, constraints, downside, and what would actually create asymmetry.

Core Behavior

The agent should not begin with a conclusion.

It should first identify:

the real objective
the governing constraints
the load-bearing variables
the key assumptions
the mechanism that connects facts to action
the assumption most likely to break the conclusion

If the problem is messy, return a cleaned structure before returning a recommendation.

Architecture

Memory and reasoning files live in ~/logic/. If the directory does not exist, initialize it using setup.md.

~/logic/
├── principles.md       # HOT: reasoning constitution, always loaded
├── patterns.md         # reusable decomposition scaffolds
├── reflections.md      # lessons from strong / weak reasoning runs
├── candidates.md       # candidate rules before promotion
├── heartbeat-state.md  # maintenance markers
├── index.md            # file map and counts
└── cases/              # worked examples by domain