Claude Skills by donald-ada

Answer build-or-adopt honestly, then design one committed architecture from your own understanding of the problem — stress-tested against the field, its consequences confirmed by the user. A command the user types, for greenfield or architecture-shaping work; standalone, no other skill required.

Find the unknowns before they find the work — a read-only territory pass that surfaces the questions nobody knew to ask, judgment taught before a choice is extracted, and a quiz that catches the user's map up with what actually changed. Use when work enters territory the user calls unfamiliar, when the user is confirming a choice they can't evaluate, or when the user asks what they're missing or wants to be quizzed before accepting built work.

Put the compaction question to a snapshot that drifted — route what no longer constrains unfinished work, and say what moves before moving it. In flight or done; the log is appended to, never edited or trimmed.

Keep the index of the project's settled decisions in .genius/DECIDED.md — one line per decision, pointing at the fight that settled it, earned by one test: would a future stranger re-fight this? Use when such a decision lands, when a design might contradict a settled one, or when another skill needs the index discipline.

Settle the look before the pixels — name the base and the delta, settle taste by looking, commit one design language to DESIGN.md. A command the user types, for work with an interface someone will see; standalone, no other skill required.

Debugging as the six geniuses at minute scale — the bug confirmed by a red reproduction before any theory, hypotheses plural with kill-reasons before any fix, the fix proven by a fresh green rerun. Use when something is broken, throwing, failing, flaky, or slow, or when the user asks to debug or diagnose.

Attack every explored path adversarially, commit to one, and present the commitment — consequences for the user to confirm, kills on the record. Use when a tracked piece of work is at its discernment stage, or when handed a ready-made plan that deserves an attack before implementation.

Retroactively distill the logs of finished work — delete what the repo now answers, keep what code cannot say. Done work only; in-flight logs are never touched.

Maintain the project's shared vocabulary in CONTEXT.md — challenge conflicting terms, sharpen fuzzy language, record resolutions inline. Use when a term conflicts with or is missing from the glossary, when a decision names a new concept, or when another skill needs the glossary discipline.

Build one slice at a time with red-before-green tests at the agreed seams, tight feedback loops, and fresh-eyes review at every slice close. Use when a tracked piece of work is at its enablement stage and a slice needs building.

Correct what was written wrong — the binding line rewritten in place, the record it came from appended to and never touched, both carrying the evidence that overturned it. Use when a run, a file, or the user contradicts something already written in a work file, a plan's contract, the glossary, or the decision index; when a pinned value or a stated fact turns out not to hold; or when another skill needs the correction discipline.

Turn the chosen design into mobilized work — a brief, vertical slices with acceptance criteria, and agreed test seams. Use when a tracked piece of work is at its galvanizing stage.

Read and update Working Genius work files — the work's folder holding the bounded snapshot a cold session acts on, the append-only log behind it, and the contract that binds the unbuilt slices. Use when a stage skill needs the work-file discipline, when the user asks what work is in flight or where a piece of work left off, or before resuming any work tracked under .genius/.

The map of the Working Genius workflow — where each piece of work stands, what to run next, and where genius gaps are hiding.

Genuinely explore structurally different approaches before committing — the alternatives exist to be beaten, not to be presented. Use when a tracked piece of work is at its invention stage.

Move an in-flight two-file work into the folder layout — snapshot, log and artifacts into .genius/<slug>/, the contract out into CONTRACT.md, every link rebased. In-flight only; finished work is never converted.

Check the project's binding documents against the repo they describe — settled decisions, glossary terms, pinned commands, in-flight plan contracts, the links between file and record — and route every drift to its correction.

How the flow's records are written — every document under .genius/, snapshot to backlog line. Use when writing or rewriting any of them, or when another skill needs the prose discipline.

Per-repo configuration — pin the work-file directory, verify commands, and issue tracking, seed the project docs, and leave the pointer that tells every future session this project works this way.

Drive the work to actually-done — fresh verification of every claim, context-isolated diff review, cleanup, commit, post-mortem. Use when a tracked piece of work is ready to close out, whether it moved through slices or was built directly after Wonder without them.

Put the backlog's own rules to the backlog — seeds that should no longer be there, pairs that are one discovery, seeds that outgrew a line, and the order nobody has stated. Judged one at a time, landed only by the user's call.

Re-explain what was just said for a reader who got lost — missing premises added, plain language, the project's own vocabulary, and one closing check that the repair landed. User-invoked only; only the reader knows when understanding broke.

Question the work before doing it — the interview that turns a raw idea into a confirmed problem statement. Use when a tracked piece of work is at its wonder stage, or when the user asks to start the Working Genius flow — or to be questioned — on a new idea. An ordinary request to build something is not an invitation to start the flow.