scalable-thinking
Design for scale while keeping implementation simple (KISS).
Best use case
scalable-thinking is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Design for scale while keeping implementation simple (KISS).
Teams using scalable-thinking should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/scalable-thinking/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How scalable-thinking Compares
| Feature / Agent | scalable-thinking | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Design for scale while keeping implementation simple (KISS).
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
> **AI-consumed reference.** Optimized for Claude to read during execution.
> Human-readable explanation: see [docs/architecture/HIERARCHICAL_PLANNING.md](../../../docs/architecture/HIERARCHICAL_PLANNING.md)
> or [docs/getting-started/](../../../docs/getting-started/) depending on topic.
# Skill: Scalable Thinking
**Principle:** Think Scalable, Build Simple.
| Aspect | Scalable Thinking (WHAT) | KISS (HOW) |
|--------|--------------------------|------------|
| Data Model | Normalized, indexed | Simple queries |
| API | Versioned, RESTful | Standard CRUD |
| Code Structure | Feature-based | Flat hierarchy |
| Config | Centralized | Single file |
---
## Where to Apply
### Data Models
Separate related data into proper tables (not JSON strings). Enables querying, indexing, partitioning.
### APIs
RESTful resource paths with versioning: `/api/v1/users/:userId/processes`. Cacheable, evolvable.
### Database
Normalized tables with foreign keys and indexes. Not JSON blobs that can't be filtered.
### File Structure
Feature-based: `src/features/{feature}/{hooks,components,api}/` + `src/shared/`.
---
## Scalable Patterns
- **Pagination:** Cursor-based `?limit=20&cursor=abc` with `{ nextCursor, hasMore }`
- **Centralized config:** Single config object with env-based values
- **Structured errors:** `AppError` with code + statusCode
---
## Anti-Patterns
| Anti-Pattern | Instead |
|--------------|---------|
| Build for hypothetical 1M users | Simple monolith first |
| Pre-optimize with Redis | In-memory cache, add Redis when measured |
| Abstract for 1 use case | Direct impl, abstract at 2-3 examples |
| Microservices from day 1 | Monolith, split when team/features grow |
---
## Checklist
**Before designing:** Can model support 10x? Can I query needed data? Natural partition keys? API versioned? Pagination for lists?
**During:** Standard patterns? Simplest solution? Junior dev understandable? No abstractions until 3+ examples?
---
## When to Scale Up
Add complexity when: DB queries > 2s, API p95 > 500ms, error rate > 1%, 10x growth in 3 months, team > 5. Until then: keep simple, measure everything.
---Related Skills
sequential-thinking
Structured thinking process for complex analysis. Supports revision, branching, and dynamic adjustment.
vue-expert
Vue 3 gotchas and decision criteria. Covers reactivity traps, Composition API pitfalls, and Pinia patterns.
typescript-expert
TypeScript gotchas and decision criteria covering nullish coalescing pitfalls (|| vs ??), strict tsconfig settings (noUncheckedIndexedAccess, exactOptionalPropertyTypes), type guard patterns, discriminated unions, and as const vs enum. Use when writing TypeScript, configuring tsconfig, implementing type guards, or debugging null/undefined errors.
tree-of-thoughts
Branch, evaluate, prune, expand — structured search over solution space. Use for architecture with multi-step decisions, refactor planning, or complex debug hypothesis trees. Paper: Yao et al. 2023.
test-writer
Write tests with TDD following structured patterns. Ensures consistent AAA structure, proper coverage targets, and framework-specific conventions. Without this skill, tests lack consistent naming, miss coverage targets, and skip anti-pattern checks.
stitch-design
Generate UI designs using Google Stitch AI with optimized prompts
session-continuation
Manage workflow state across sessions with handoff and resume. TOON-based state persistence.
self-improve
Apply learned improvements to the Aura Frog plugin. Updates rules, adjusts agent routing, modifies workflow configurations, and generates knowledge base entries.
self-healing-orchestrator
Proposes patches for F2 (local-logic) and F3 (local-design) failures. NEVER applies without user approval. Confidence ≥0.7 to propose; below that, escalates raw findings. Counts toward replan_budget. Per-task: max 1; per-session: max 5.
self-consistency
Generate N independent reasoning paths and vote on the answer. Use for architectural trade-offs, ambiguous design decisions, or when single-path reasoning risks locking onto the first plausible answer. Paper: Wang et al. 2022.
run-orchestrator
Execute 5-phase TDD workflow for complex features. Use when the user invokes /run, asks to build/create/implement a feature, requests a complex multi-file change, or types 'fasttrack:'. Enforces phase gates, sprint contracts, and builder!=reviewer discipline.
response-analyzer
MCP Response Analyzer pattern - Write large responses to temp files, load summaries into context