agentsclimarketplace
Sign in

Strategic mindset

Skill codybrom/clairvoyance/skills/strategic-mindset

Assesses whether code reflects strategic or tactical thinking, including the 10-20% investment rule and tactical-tornado patterns. Use when evaluating design investment, when code was written under time pressure, or when working code consistently degrades the system. Not for judging whether a specific diff looks designed-in or bolted-on (use code-evolution).From its SKILL.md

Install
npx -y skills add codybrom/clairvoyance --skill strategic-mindset

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 11 stars11 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.9 KB, 913 tokens by cl100k_base, as published. Nobody here has run it

Strategic Mindset Review Lens

When invoked with $ARGUMENTS, focus the analysis on the specified file, module, or codebase area. Read the target code first, then apply the checks below.

"The first step towards becoming a good software designer is to realize that working code isn't enough." — John Ousterhout, A Philosophy of Software Design

Evaluate whether code invests in design or just gets the job done.

When to Apply

  • When reviewing code written under time pressure
  • When assessing technical debt in a codebase
  • When a developer consistently produces working code that degrades the system
  • When deciding how much time to invest in a design

Core Principles

Strategic vs. Tactical

Tactical Programming

Get it working, move on. Each shortcut is locally defensible. This is precisely what makes it dangerous: it doesn't feel dangerous.

Strategic Programming

Produce a great design that also happens to work. Two modes:

  • Proactive: Explore alternatives before implementing. Write documentation before code to surface interface problems early.
  • Reactive: When you discover a design problem, fix it.

See code-evolution's "Designed This Way" test for the full three-question procedure (what would this look like designed from scratch; does the modification match that; what's the minimum restructuring to close the gap).

The Unit of Development Should Be an Abstraction

Working in abstraction-sized chunks lets you consider trade-offs and arrive at general-purpose solutions. Once you discover the need for an abstraction, design it all at once. Don't create it in pieces over time. Working in test-sized chunks (write one test, make it pass) encourages tiny increments that never step back for the big picture. TDD risks becoming tactical programming with a disciplined veneer. Each increment is responsible, but the aggregate drifts toward specialization because no step encourages holistic design thinking.

The 10-20% Investment Rule

  • Not all upfront. Spread across the project
  • Not a separate refactoring pass or cleanup session — woven into every task.
  • Each task should leave the system slightly better than it found it

Crossover point estimated at 6-18 months, after which design quality saves more time than investments cost. (Ousterhout calls this "just my opinion" with "no data to back it up.")

The Slippery Slope

Once you start cutting corners, it quickly becomes the default. "Add a TODO" and "make a backlog ticket" are how shortcuts you should have never taken become permanent. Tactical code is extremely difficult to fix after the fact and the payoff for good design comes quickly enough that cutting corners may not even save time on the current task.

Good software design makes every collaborator more effective. Humans, agents and subagents all produce better work in less time with fewer prompts/tokens when the code they're building on is clean. Bad design does the opposite: every contributor spends more time fighting the system than improving it, and their output degrades the system further.

Design It Twice

Before committing to any significant design, generate at least two fundamentally different approaches and compare on concrete criteria. See the design-it-twice skill for the full procedure and comparison checklist.

Tactical Tornado

A developer who produces impressive output by cutting design corners. The damage is invisible, or worse, looks like inefficiency from whoever follows them. The causal chain doesn't surface naturally.

Signs in code:

  • Quick fixes layered on quick fixes
  • Copy-paste with minor modifications instead of generalization
  • "It works" treated as sufficient
  • Undocumented dependencies

Zero Tolerance

Each shortcut makes the next one easier to justify. The first accepted shortcut sets a precedent. The second cites the first. Selective tolerance is normalization in progress.

This doesn't mean over-engineer. It means: do the simple, clean thing instead of the hacky thing.

Review Process

  1. Assess approach: Strategic or tactical?
  2. Evaluate investment: Did this change improve the system beyond the immediate requirement?
  3. Scan for tactical patterns: Copy-paste, quick fixes, missing abstractions?
  4. Project forward: If the next 10 changes follow this pattern, what happens?
  5. Recommend: Specific investments with estimated effort

Red flag signals for strategic mindset are cataloged in red-flags (Tactical Momentum).

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most roadmap strategy skills give in 913 tokens

Counted across 614 of the 719 authors here whose files we hold, read 2026-09-06

  • Check for product marketing context firstin 39 of 614, across 16 files
  • Use compact with a custom summaryin 32 of 614, across 16 files
  • Compact after planningin 30 of 614, across 16 files
  • Do not compact mid-implementationin 30 of 614, across 17 files
  • Structure launch marketing across three channel typesin 21 of 614, across 5 files
  • Read the compaction suggestionin 20 of 614, across 10 files
  • Write before compactingin 17 of 614, across 11 files
  • Write important context to files before compactingin 16 of 614, across 5 files
  • Recruit early users one-on-onein 16 of 614, across 3 files
  • Identify 3-5 core content pillarsin 15 of 614, across 9 files
  • Target a specific keyword or questionin 14 of 614, across 4 files
  • Stagger announcements to maintain momentumin 14 of 614, across 4 files

Said here and by no other author read

  • Focus the analysis on the specified file
  • Read the target code first
  • Assess whether code is strategic or tactical
  • Evaluate whether the change improved the system
  • Scan the code for tactical patterns
  • Project forward the pattern of changes

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 325,949. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.