XyraSinclair

@xyrasinclair source repo

16 skills
0 followers
10 hours ago last updated

▌
Consult The Atlas · xyrasinclair
Before planning or brainstorming in a territory the catalog already maps, retrieve the lists and maps the situation belongs to and run them as instruments: stand on the axis, label every member present / ruled-out / unlabeled, walk the edges for consequences the plan did not state, and take the pre-written probes. Use at the start of a hard plan, a negotiation, a raise, a pricing or survival call, or whenever a brainstorm sounds like the model's default. The failure it prevents: sampling the mode when a bounded denominator for the situation already exists on disk.

0
installs
▌
Localize Then Glue · xyrasinclair
When a global attack stalls — the system is too coupled, the proof too wide, the rollout too distributed, the synthesis too brittle — stop pretending the whole thing must yield in one piece. Solve it on tractable patches, then compute exactly what fails on the overlaps. The failure it prevents: the monolithic global attack that silently fails, or the false clean solution that "mostly works" locally but never actually glues. Triggers on distributed changes, patchwise proofs, cross-service migrations, multi-part synthesis, and any task whose local pieces are easier than their boundary conditions.

0
installs
▌
Preserve The Target · xyrasinclair
The universal pre-gate that wraps every other skill. Every cognitive move TRANSFORMS the problem — tests it, reframes it, localizes it, names it, formalizes it, dimensionalizes it, persists it — and the sharpest failure is not that the move is non-executable, it is that the move executes CLEANLY on a transformed target that is no longer the one that mattered. The failure it prevents: gate laundering / high-assurance wrongness — an oracle for the wrong claim, a smallest case that misses the phase transition, an MDL-shorter reframe that dropped a constraint, a coined concept that compresses language but not reality, a mechanism equilibrium under the wrong utility, a coverage denominator that omits the real branch, a ledger that preserves yesterday's wrong frame. Run it before and after any skill that changes the problem.

0
installs
▌
Practice Deep Ideonomy · xyrasinclair
Deep ideonomy: discover surprising distinctions through typed lists, revealing seriations, and relational maps. Use for exploratory or speculative idea-making, when a brainstorm feels generic, or when choosing which strange possibility deserves another breath.

0
installs
▌
Route To The Right Move · xyrasinclair
Before answering substantively, diagnose the problem's shape and dispatch to the right premier skill instead of defaulting to fluent prose. Use when the next move is unclear, when several skills plausibly apply, or whenever the first draft of the response sounds generic because no hard cognitive move has been chosen yet. The failure it prevents: prose-first reasoning and misrouted rigor, where the model applies the wrong discipline, skips the only honest gate, or manufactures work at the wrong level because it never classified the problem it was facing.

0
installs
▌
Coin The Missing Concept · xyrasinclair
When the same awkward phrase keeps recurring — "the kind of bug where...", "this class of lines that...", "that pattern we keep tripping on but have no name for" — treat the repetition as residue signaling a missing concept. Coin a precise noun, give it a decidable membership test, and keep it only if the corpus compresses. The failure it prevents: endless circumlocution standing in for a concept, where the model repeatedly gestures at the same structure but never binds a handle that lets the structure be reused or tested. Triggers on repeated locutions, taxonomic awkwardness, and any review where the same explanation is written three times with different wording.

0
installs
▌
Audit The Oracle Coverage · xyrasinclair
The dangerous case is not "no oracle" — it is a WEAK oracle you falsely believe is exact. Before trusting any test suite, metric, benchmark, eval, or proof as if it settled the question, state explicitly what it CERTIFIES and what it does NOT — the gap between the proxy and the target. The failure it prevents: false certainty from a passing check that silently misses the spec (tests green but the spec was wrong), proxies value (offline metric up, user value flat), or has drifted (backtest on a system that has since changed). Triggers whenever a check comes back positive and you are tempted to call the thing "verified", and as the mandatory middle step between build-the-oracle-before-the-answer and triangulate-without-oracle.

0
installs
▌
Reframe Until It Dissolves · xyrasinclair
When a problem is grinding — casework piling up, effort scaling without progress, "it depends on everything" — stop answering at the level it was posed and change the representation until it becomes mechanical or disappears. Raise the abstraction (the general statement is often EASIER), change the basis (until the coupling vanishes), or transport the solution from a domain where it's already solved. The failure it prevents: the LLM's deepest default — answering at exactly the posed level, scaling effort instead of changing representation, conflating "this is hard" with "this is hard in these coordinates." Guarded by an MDL anti-vacuity gate so it never floats off into empty over-abstraction.

0
installs
▌
Triangulate Without Oracle · xyrasinclair
Stay rigorous on questions that have NO computable oracle — taste, register, ethics, strategy, "is this good / right / worth it". Use when you catch yourself about to score an irreducibly normative or aesthetic thing with a single made-up number (7/10, "high quality", "this is the right call"). The danger it prevents: an LLM invents a metric, optimizes it with full rigor, and ships a confidently-wrong answer to a question that never had a metric — Goodhart at the epistemic level, worse than no rigor. Triggers on value judgments, design/copy review, prioritization, "which is better" where "better" is contested, and anywhere a proxy oracle would amputate the thing that mattered.

0
installs
▌
Refute Your Own Answer Blind · xyrasinclair
When an answer arrives suspiciously clean — especially on a high-stakes claim, a safety judgment, or anything your own confidence is trying to launder into truth — strip authorship and confidence, pay an adversary to destroy it, and require the attacks to fail on execution rather than on counter-prose. The failure it prevents: self-preference and plausibility bias, where the model protects its own first answer because it sounds coherent and every review quietly reuses that same coherence. Triggers on "this should work", policy/safety claims, migration plans, root-cause explanations, and answers whose per-step confidence is uniformly high.

0
installs
▌
Prove The Coverage Denominator · xyrasinclair
Whenever you are tempted to say "done", "complete", "fully reviewed", "all sources covered", or "the migration is comprehensive", force the denominator into the open first. State the full space of cases, sources, branches, or entities under discussion, then label every element. The failure it prevents: declaring exhaustiveness because the largest or easiest visible case landed while the rest of the denominator stayed implicit and therefore unjudged. Triggers on audits, corpus ingestion, test coverage, literature reviews, source enumeration, and any completeness claim that could hide an unlabeled remainder.

0
installs
▌
Build The Oracle Before The Answer · xyrasinclair
Defeat answer-then-rationalize: when a claim is checkable more cheaply than it is producible (a row count, a benchmark number, "this refactor preserves behavior", a combinatorial count, "this query returns X"), write the independent truth-check AND commit its expected value BEFORE you produce the answer. The failure it prevents: an LLM emits a fluent answer and then manufactures support for whatever it already said — verification collapses into self-agreement because the check was built after the answer. Triggers on any quantitative or verifiable claim, especially counts, latencies, "this works", and anything you'd be tempted to assert without running.

0
installs
▌
Compute The Smallest Nontrivial Case · xyrasinclair
When a general claim arrives too easily — a formula, an invariant, "this mechanism works", "the query logic is correct" — force it down to the smallest concrete instance that still exercises the core mechanism and compute it by hand before you generalize. The failure it prevents: leaping to a clean universal statement that was never made to survive contact with even one concrete case. Triggers on derivations, counting arguments, algorithm claims, edge behavior, and anywhere the words "obviously for all n" appear before one nontrivial n was worked.

0
installs
▌
Enumerate Discriminating Alternatives · xyrasinclair
When one narrative starts dominating early — a bug explanation, a market story, a user motive, "the obvious cause" — stop converging and force at least four live alternatives, each still consistent with what has been seen and each carrying a prediction that would distinguish it from the others. The failure it prevents: premature single-story convergence, where an LLM locks onto the first coherent explanation and then merely accumulates supporting details for it. Triggers on diagnosis, causal inference, incident review, strategy explanation, and anywhere two different stories could still fit the same facts.

0
installs
▌
Carry The Residue Forward Across Sessions · xyrasinclair
Stop re-deriving from zero every session. At the close of any non-trivial work session, extract what RESISTED resolution — anomalies, reframes that failed, objections that survived, named-but-unfilled gaps, contested judgments, the unexplained core of a distillation — and persist it as the retrievable SEED for the next session. At the start of the next session, retrieve and cite it before expanding. The failure it prevents: total amnesia between sessions, where residue evaporates and nothing compounds. Triggers at session boundaries, before "I'll pick this up later", and whenever you notice you're re-discovering something a past session already surfaced.

0
installs
▌
Design The Mechanism From The Desired Equilibrium · xyrasinclair
When the task is to set rules, incentives, or metrics — "how should we score this", "what policy makes agents tell the truth", "how do we reward the right behavior" — do not propose a rule and hope it induces the outcome. Start from the behavior you want as a best-response and build backward through a strategyproof template, treating the metric-gamer, often the model itself, as adversary. The failure it prevents: hope-based governance and gamable metrics, where the optimizer satisfies the letter of the score while defecting against the intent. Triggers on rubrics, auctions, evaluation design, agent incentives, and any metric someone will optimize against.

0
installs

16 published skills