agentleFS
imMamdouhaboammarimMamdouhaboammar/anti-slop-engineering/skills/future-scale-gate/SKILL.md

future-scale-gate

Skill4 starsChanged 31 days agoMITView on GitHub

Use before committing to hard-to-reverse foundations for a long-lived software product, language, runtime, data model, or platform; when current workload evidence is being used to dismiss credible growth requirements; or when a team wants to build for extreme future scale without proving which foundations matter. Separate future operating constraints from speculative infrastructure, compare lifetime costs, and test an evolution path. Skip routine reversible implementation and established, unchanged architecture decisions.

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 3 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Do not block ordinary work with repeated future-proofing checklists.

    line 33
  2. Distinctive:

    No “future-proof” claims from interfaces alone: Verify a representative evolution path with an alternate consumer/backend, migration …

    line 40
  3. Distinctive:

    Run a bounded architectural fitness experiment for the costly boundary (second engine, schema evolution, tenant split, concurrency stress, …

    line 66

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Future-Scale Gate

Design for credible future change; implement only the capacity and foundations justified now.

Own the right problem

This Skill owns architectural evolution capacity: whether today's structural choices prevent credible future workloads, users, deployment models, or extensions. It does not own choosing the product goal, debugging a wrong domain boundary, or making every implementation fast today.

  • Decision Guard determines whether the proposed product, stack, or metric approach is needed and compares independent choices. Use it first if the basic direction is undecided.
  • Root-Fix Gate traces the existing owner of a bug or scattered invariant. Use it for cross-layer fixes, not speculative redesign.
  • Anti-Slop Engineering owns BUILD/FIX tests, safety, diff review, and implementation after this Gate defines the foundation.

Activation and refusal

SignalAction
A language/runtime, persistence contract, core API, or irreversible data model is being establishedRun an operating-envelope and reversal-cost assessment
“No performance problem today, so this cannot matter” dismisses a plausible future operating constraintSeparate measuring a hotspot from designing capacity for future workloads
“Plan for millions” is used to demand microservices, sharding, or distributed execution immediatelyDemand a credible scenario, migration barrier, and bounded evolution proof
A later engine, tenant model, or deployment target might be blocked by a current designTest the smallest representative evolution path before commitment
A localized feature is reversible within existing stable boundariesSkip this Skill; use BUILD/FIX
A direct answer exists or the underlying solution is questionableRoute to Decision Guard before architecture work

Do not block ordinary work with repeated future-proofing checklists. Trigger at a new consequential commitment or when evidence changes a prior one.

Non-negotiable invariants

  1. Future scenarios are not predictions. Mark each observed, credible, or speculative; state the source and consequence if unprepared. An inaccessible source is unknown, not absence of need.
  2. Future readiness and future implementation are different. Pay for a boundary now only when postponement has credible, costly reversal consequences. Defer expensive capacity until its trigger.
  3. Reversibility sets the proof burden. Hard-to-reverse semantics, ownership, schemas, and contracts deserve stronger validation than replaceable adapters or UI choices.
  4. No “future-proof” claims from interfaces alone. Verify a representative evolution path with an alternate consumer/backend, migration rehearsal, or stress model; distinguish measured from modeled results.
  5. Compare lifecycle ownership, not just day-one LOC. Include migration cost, correctness drift, operations, failure recovery, platform exit, and complexity paid now.
  6. No scale dogma. Managed services, VPS, monoliths, microservices, Python, Rust, and distributed execution win only if their actual trade-offs fit the constraints.
  7. Protect user authority. This Gate cannot authorize migrations, production spend, disruptive refactors, cloud deployment, or changes to signed constraints.
  8. Preserve semantics under evolution. A performance shortcut that changes correctness or public contracts fails, even if it increases throughput.

Execution router

Evidence stateDecisionHandoff
Credible future, expensive reversal, cheap foundation, feasible evolution testproceed with foundation onlyAnti-Slop BUILD; defer infrastructure with triggers
Credible future, reversal expensive, but necessary boundary/proof unknownpauseSmallest source check or evolution spike; do not lock the design
Future only speculative and expensive to prepare for nowstop speculative investmentMaintain replaceable design and a revisit trigger
Scale is already failing under a proven workloadRoute to performance diagnosisMeasure causes; protect architectural contracts while optimizing
Future demand requires a signed change of product scope or budgetpause for authorityShow choice, cost, and consequence without deploying
No consequential commitment or meaningful migration hazardReturn to BUILD/FIXNo record, no extra ceremony

Workflows

Before commitment: Architect

  1. Identify the product's expected lifetime and types of future users, workloads, growth, failure, and extension; do not invent exact growth forecasts.
  2. Classify evidence. Define a future operating envelope across materially different stresses when relevant; one grounded irreversible requirement is sufficient without inventing another. Name the failure mode if unprepared.
  3. Name hard-to-reverse choices. For each, state why reversal is costly and how exit/migration could work.
  4. Compare credible designs across current complexity, lifecycle cost, failure/recovery, and exit cost. If a hard constraint leaves only one viable option, cite it instead of inventing a fake alternative. Separate framework, hosting, persistence, and execution axes when they differ.
  5. Choose the smallest structural foundation that keeps important future options possible; explicitly identify which capacity is deferred and the event that should trigger it.
  6. Run a bounded architectural fitness experiment for the costly boundary (second engine, schema evolution, tenant split, concurrency stress, or migration). A passing checklist is not that experiment.
  7. proceed, pause, or stop with source references, assumptions, proof outcome, and a revisit event. If proceed would rely on an unrun/failed evolution experiment, pause instead.

For trade-off methods and concrete non-happy-path examples, read foundation method before committing to an expensive boundary.

After implementation: Review

Trace whether the foundation is actually present, whether deferred work accidentally shipped, and whether a future consumer can use the contract without a rewrite. Compare the real diff, tests and operational changes to the record. Reopen the design if implementation invalidates its assumptions.

Record and machine audit

For consequential choices, record the decision using record contract; include a concrete evolution proof and deferred-work trigger. Example: runtime envelope.

python3 scripts/future_scale_guard.py audit path/to/record.json --json
# Or, when the package CLI is available:
node bin/cli.js future-scale audit path/to/record.json --json

The checker validates structure and referenced evidence statuses, not scenario plausibility, independent proof truth, expected load, or architecture quality. 0 = structurally complete, 2 = incomplete, 1 = invalid input. For pause and stop, record honest uncertainty without manufacturing a completed proceed packet.

Failure taxonomy

FailureObservable signalRecovery
Present-only optimization“No bottleneck today” used to dismiss irreversible runtime couplingIdentify future operating envelope and reversal cost
Capacity theaterCluster or distributed stack before a supported use caseSeparate stable boundary from deferred scale implementation
Interface theater“It is modular” but second consumer cannot run unchanged semanticsBuild the smallest alternate consumer/proof
Forecast theaterExact loads/costs invented to justify a decisionUse explicit qualitative scenarios and measurements
Foundation launderingExpensive abstraction with no credible scenario or exit riskRemove it or supply a falsifiable scenario and proof
Sunk-cost defensePrior implementation effort used to dismiss contrary evidenceCompare forward costs and revisit the commitment
Premature permanenceDatabase/schema/IR choice locks the public contract by accidentVersion, migrate, and test compatibility before hardening

Completion

Hand off: long-term goal, evidence-ranked future envelope, consequential choices and reversal cost, competing options, chosen foundation versus deferred capacity, evolution proof evidence, test changes, unresolved unknowns, authority boundary and revisit triggers. Treat evaluation scenarios as proposed tests, not as verified model performance.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.