celestialdust

@celestialdust source repo

40 skills
0 followers
11 hours ago last updated

▌
CI CD · celestialdust
Stands up and hardens the quality-gate CI/CD pipeline so no change reaches production without passing lint, types, tests, build, and audit. Use when setting up or modifying build/deploy pipelines, automating quality gates, configuring test runners or branch protection in CI, debugging CI failures, or deciding a deployment/feature-flag/rollback strategy. Reach for this whenever a change should trigger automated verification.

0
installs
▌
To Prd · celestialdust
Synthesize the grilled intent + design substrate into a product-altitude prd.md — NO interview, just synthesis of what you already discussed. Reach for this the moment intent.md is pinned and the ADRs are written and you need the dual-audience product spec the whole pipeline reads. STAY at product altitude: reference ADRs by id, use CONTEXT.md terms verbatim, and NEVER paste a file path, signature, or schema into the PRD.

0
installs
▌
Handoff · celestialdust
Compact the current session into a cold-start handoff the MOMENT context fills, the work pauses, or you are about to /clear — so a fresh agent resumes from durable state, not a lost conversation. Writes the 5-field snapshot to docs/session-state.md and appends decisions (the reason, what was ruled out, what is still open) to docs/session-log.md, the separate append-only record; references artifacts by path instead of duplicating them, and redacts every secret. Use BEFORE you lose context, not after — and whenever a decision was made that a later session would otherwise re-open.

0
installs
▌
Worktree · celestialdust
Use the instant a slice is about to be implemented and needs its own isolated, clean-baseline workspace — BEFORE any code is written. Detects existing isolation first (never double-nests, never fights the harness), prefers a native worktree tool over raw `git worktree add`, installs deps, and proves the test baseline is green so new failures are distinguishable from old ones. If you are about to run `git worktree add` without checking whether you are already isolated or a native tool exists, or about to start implementing without a verified-clean baseline — STOP and use this.

0
installs
▌
API Design · celestialdust
Designs stable, hard-to-misuse interface contracts BEFORE implementation — the types ARE the spec. Reach for this the moment spec-grilling needs a structural variant for a load-bearing interface question, or plan-breakdown needs to pin a module boundary, a REST or GraphQL endpoint, a component prop interface, or a cross-module type contract: define the contract first, validate only at boundaries, prefer addition over modification, and treat every observable behavior as a commitment (Hyrum's Law) under one version (the One-Version Rule). Land the contract in plan.md; escalate any hard-to-reverse interface decision to an ADR.

0
installs
▌
Code Review · celestialdust
Five-axis code review — correctness, readability, architecture, security, performance — INCLUDING test quality, with severity-labeled findings (Critical/Required/Optional/Nit/FYI) and change-sizing. Reach for this BEFORE any slice's PR opens; never eyeball a diff. Use whenever you review code written by yourself, another agent, or a human, or whenever the orchestrator dispatches the Review fan-out. If you are about to approve a diff without grading all five axes, stop and load this first.

0
installs
▌
Idea Refine · celestialdust bundle
Refine a raw or half-formed idea into a sharp, buildable concept through structured divergent-then-convergent thinking, always surfacing hidden assumptions and an explicit "Not Doing" list. Use this in the Ideate stage BEFORE Spec whenever an idea is still vague, whenever you are tempted to jump straight to a plan without stress-testing it, or whenever you want to expand options before converging. Refines (and SHARES) intent.md — never write a separate one-pager. Triggers on "ideate", "refine this idea", "help me think through X", "stress-test my plan/idea", or "show/make me options I can react to".

0
installs
▌
Spec Review · celestialdust
Use this LAST in the Spec stage, before the human signs off — a fresh code-cold agent that FIXES the spec instead of listing complaints. You MUST run it after spec-grilling/to-prd/acceptance-criteria/environment-manifest (plus frontend-design for UI and architecture-design for a structure pass) land and before the Spec gate, while the whole bundle is still draft. It auto-fixes decidable facts (stray file paths/signatures in prd.md, dangling `see ADR-NNN`, non-verbatim CONTEXT terms, placeholders, embedded secrets/commands in environment.md) and applies-then-inline-flags contestable judgment fixes (coverage gaps, ADR-worthiness, one-feature-or-two), handing back a cleaned spec, not a punch-list.

0
installs
▌
Git Workflow · celestialdust
Trunk-based git discipline — atomic save-point commits (~100 lines, one logical change), short-lived branches, descriptive why-not-what messages, and a hard secret scan before every commit. Use this BEFORE every commit, branch, merge, or revert. Git is always on: if you are about to write code or type `git commit`, you are already in this skill's scope. Skipping it means giant unreviewable commits, secrets baked into history, and lost save-points.

0
installs
▌
Interview Me · celestialdust
Extracts what the user actually wants instead of what they think they should want. Achieves this through one-question-at-a-time interview until ~95% confidence about the underlying intent. Use when an ask is underspecified ("build me X" without "for whom" or "why now"), when the user explicitly invokes ("interview me", "grill me", "are we sure?", "stress-test my thinking"), when you catch yourself silently filling in ambiguous requirements before any plan, spec, or code exists, or when the user asks what they're missing, wants their blind spots surfaced, or says "quiz me" before committing.

0
installs
▌
Orchestrator · celestialdust
Drives the autonomous Implement→Verify→Review→Ship loop once the human-owned Spec+Plan is signed and STATE.md holds a slice DAG. Use it to run a build AFK — it sorts slices into topological waves, runs each wave's ready slices in parallel (one worktree per slice, disjoint files only), holds a barrier until every slice reaches a TERMINAL state (done/halted/blocked — never just "success"), and ends the run at risk-banded OPEN PRs for async human merge. If you are about to hand-run slices one at a time, check in with the human between waves, dispatch a "reviewer" persona, weaken a frozen test/acceptance to make a gate go green, or merge to main yourself — STOP and use this instead.

0
installs
▌
Pull Request · celestialdust
Open a design-anchored DRAFT pull request that ENDS a slice — turn green, reviewed code into it, then STOP. Reach for this the moment a slice's three internal gates are green (qa.md pass · review fan-out clear · evaluator floors met). It anchors the Summary to prd.md + ADRs (NEVER a commit-log dump), names the 3-5 highest-risk files as a mandatory reviewer code-reading checklist, builds the test plan from qa.md's ledger with a REQUIRED human-ack line for every not-reachable scenario, attaches an inverted risk band that the diff's blast radius raises, and opens an OPEN draft PR on the slice branch for async human merge. It NEVER merges to main, marks the PR ready, or triggers a deploy — the human owns the merge. If you are tempted to skip the read-the-code checklist, open a PR without a passing verify gate, or "just merge it to move on", use this instead.

0
installs
▌
Gauntlet Loop · celestialdust
Grinds a throwaway prototype until it beats a real outside reference — name one fetchable bar, split the goal into independently judgeable pieces, and run a builder against a separate blind critic on each until the critic picks ours. Emits a paste-ready prompt for a fresh session, and runs the loop here when asked. The fast path for a proof of concept; anything that will ship uses the lifecycle skills. Use when someone types /gauntlet-loop or says "gauntlet this", "loop until it beats X", "run the gauntlet", or asks for a gauntlet prompt. An ask that merely sounds fast never selects it — quick is a tone, not a scope, so using-agent-skills offers this path beside the full loop and the human picks. Needs a person in the session: fetching a bar can mean running code from outside the repository, and every fetch waits for your yes. Standalone — no lifecycle gates, nothing blocks, /orchestrate untouched.

0
installs
▌
Project Setup · celestialdust bundle
Scaffolds the repo ecosystem every achilles skill assumes — a one-time bootstrap that creates the STATE.md board, the CONTEXT.md glossary, docs/adr/, docs/features/, docs/session-state.md (the five-field snapshot of where the work stands), docs/session-log.md (the separate append-only record of decisions a resuming session reads before re-opening a question), docs/progress.md (the run record — what each slice actually executed, appended to and never rewritten, scaffolded with the entry shape and no entries), and docs/lessons.md (the lessons record — what a root-caused defect turned out to be and the guard that would catch it coming back, appended to and never rewritten, scaffolded with the field template and no entries), and the `## Agent skills` block in one of CLAUDE.md / AGENTS.md plus a short pointer to it in the other — and, when the repo has neither and you opt to create CLAUDE.md, seeds it from a bundled behavioral template. Run this ONCE before the first feature, before interview-me or spec-grilling.

0
installs
▌
Spec Grilling · celestialdust bundle
Use BEFORE writing any PRD or design doc — whenever the user wants to design a feature from an idea or intent.md, stress-test a design, pin down domain terminology, surface design decisions the user hasn't considered, or record an architectural decision. Runs after codebase-research's goal-blind survey and refuses without research.md, so the design is decided against the codebase as it is rather than against recollection. Interview relentlessly, ONE question at a time, with a recommended answer each. Grills the structural branch too — which parts earn their existence, what has to be swappable, what a consumer's surface may depend on — fanning out codebase-design or api-design variants on a load-bearing one so the person chooses. Emits ADRs + CONTEXT.md; never a PRD.

0
installs
▌
Plan Breakdown · celestialdust
THE planner — turns a signed prd.md + research.md + architecture.md into a concrete, agent-executable plan. Reach for it the moment Plan starts and someone says "plan this", "break it into tasks", "write the implementation plan", or is tempted to hand the build agent a prose sketch. It ELABORATES the structural decisions already recorded during Spec instead of reopening them, and supplies the depth they left — typed signatures, field lists, vertical tracer-bullet slices (each demoable, cross-layer, with an observable checkpoint) whose concrete steps live one file per slice under `plan/`, mapped from the slice table in plan.md, where every non-trivial step names its file, line range, code snippet, and test, plus a Blocked-by dependency DAG written into STATE.md. Refuses horizontal layer-by-layer plans and placeholder steps; references codebase-design + api-design.

0
installs
▌
Codebase Design · celestialdust bundle
Shared vocabulary and method for designing deep modules — a lot of behaviour behind a small interface, at a clean seam, testable through it. Use when spec-grilling needs a structural variant for a load-bearing question during Spec, when planning a module's interface during plan-breakdown, when the user wants to design or improve an interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary. Reach for it BEFORE you write interface signatures into plan.md — designing the seam after the code exists is too late.

0
installs
▌
Frontend Design · celestialdust bundle
Use whenever a feature decides what something looks like — it authors the markup, layout, styling, or interaction structure of an output a person reads (a page, screen, component, flow, email, or message layout), however the brief is worded. Explore throwaway variants, commit ONE high-fidelity prototype as the reference-spec build target, and write the signed design contract that Verify grades against. Skip only where the feature decides nothing about presentation and merely hands data to a surface somebody else designed — the body states that test with its cases, and a borderline one is decided there. Invoke BEFORE any production UI; don't reach for a cream-serif-terracotta default.

0
installs
▌
Codebase Research · celestialdust
Map the codebase/DB exactly as it is today — a goal-blind, fact-only survey produced by parallel read sub-agents that never see the design, each persisting its own findings to docs/features/<slug>/research/ — BEFORE any design decision is made. Use this the moment Spec starts, after intent.md is signed and before spec-grilling opens the decision tree; also whenever someone says "research the codebase," "do the codebase dive," or is tempted to decide against a guess about how the code works. Run it AGAIN at the head of Plan, before plan-breakdown cuts slices — the goal-blind Spec survey mapped what the intent implied, and the signed decisions now point at code it had no reason to open. Skip either pass and the ADRs or the slices get decided against recollection.

0
installs
▌
Comprehension Quiz · celestialdust
Agent-administered retrieval practice that makes understanding of code you did not write honest — about five medium-difficulty questions asked ONE at a time, the learner's answer graded BEFORE the correct answer is revealed, the session recorded as one line in the learning ledger. Reach for this right after a literate-explainer artifact (quiz that explainer) or standalone with no fresh explainer in view (the requiz over weak or stale durable concepts drawn from the ledger). It is the SOLE writer of the learning ledger; it is an honest self-check, never a gate — it blocks nothing. If you are about to dump every question at once, reveal an answer before grading it, or write a quiz's questions or answers into any file the learner can open, stop and load this.

0
installs
▌
Literate Explainer · celestialdust
Turn a diff (the daily case) or a whole unfamiliar target repo (onboarding) into a self-contained teaching artifact so you stay a participant in code you didn't write — background before the change, intuition before details, a literate tour in reading order, plain enough to re-teach (the Feynman test). Reach for this whenever an agent just landed a large diff you cannot yet explain, when you clone or inherit an unfamiliar repo and a skim will not build a mental model, or when someone says "explain this diff/PR/branch/codebase", "walk me through what changed", or "help me understand this code". Standalone — no lifecycle gates, nothing blocks, /orchestrate untouched. Pairs with comprehension-quiz — suggest running /quiz next. NOT code-review (which judges a diff for merge) and NOT codebase-research (the goal-blind survey written at the head of Spec and again at the head of Plan).

0
installs
▌
Using Agent Skills · celestialdust
The meta-dispatcher for the achilles-skills suite. Maps any task to the right stage skill and the artifact-chain lifecycle (Ideate → Spec → Plan → Implement → Verify → Review → Ship). Use this FIRST — at the start of every session and whenever you are unsure which skill applies — before writing any plan, spec, or code. Acting without consulting this index is how the wrong skill gets run and the artifact chain gets skipped.

0
installs
▌
Acceptance Criteria · celestialdust
Turn a prd.md into acceptance.md — the Given/When/Then prose contract that is the human-anchored oracle for THIS feature's behavior across the entire autonomous run — the only human-anchored oracle the run has. Reach for this the MOMENT a prd.md exists (on a UI feature, once frontend-design has explored the interface) and BEFORE any planning, TDD, or QA — test-driven-development and quality-verification REFUSE to run without a signed acceptance.md. If you are about to write "acceptance criteria", "definition of done", test scenarios, or Given/When/Then for a feature, you need this first. Behavioral-only: keep ALL design floors out (those belong to frontend-design's contract).

0
installs
▌
Architecture Design · celestialdust bundle
Reconciles a feature's structure into an artifact a person signs before any code is planned — `architecture.md` in Anthropic's five-part system-design format (requirements · high-level design · deep dive · scale and reliability · trade-offs) plus a sixth section of open questions, alongside the committed `architecture.html` read at the Spec gate. ALWAYS run this in Spec, once `acceptance.md` exists in draft and before `spec-review`, whenever a feature adds a component, adds a dependency between parts that already exist, or changes what the system must hold to under load — and before anyone plans, breaks down, or implements against a structure nobody wrote down. The artifact is a RECAP of decisions already taken — it traces every scenario through the structure, restates the requirements and the scale posture already decided, and grades what it wrote with two code-cold sweeps whose findings become questions for the person rather than edits. It may do the load arithmetic but never picks the posture. Never invent

0
installs
▌
Code Simplification · celestialdust
Reduce code complexity without changing behavior — the Review-stage QUALITY axis. Use the moment a slice's code is green but reads heavier than it should: deep nesting, nested ternaries, dead code, generic names, copy-paste duplication, speculative abstractions. Apply Chesterton's Fence (understand before you cut) and stay scoped to what changed. Quality only — it does NOT hunt for bugs (that is `code-review`/`security-and-hardening`). It REPORTS findings and edits nothing — not the code, not the tests; a simplification that cannot be had without moving behavior, a frozen test, or the repo's decided look is a HALT, not a finding.

0
installs
▌
Preflight Readiness · celestialdust bundle
Environment-readiness gate that blocks an autonomous wave until every environment.md manifest row is provisioned — runs at the human→AFK boundary right after environment.md is signed and BEFORE the orchestrator dispatches slice one. Probes every manifest row with a read-only, value-blind prober and REFUSES to start the wave on any red or un-attested amber — never optimistically. Re-fire mid-run as a side-effect-free stall-recovery probe. Invoke whenever you are about to start, resume, or unblock an autonomous run, or whenever slices are failing in ways that smell like missing environment.

0
installs
▌
Shipping And Launch · celestialdust
Prepares production releases and authors the launch runbook. Use the moment you are preparing to ship to production, batching merged PRs into a release, or anyone asks for a pre-launch checklist, a feature-flag rollout, a staged/canary rollout plan, monitoring setup, or a rollback strategy. Starts AFTER the human merges — a slice sitting at an open draft PR belongs to `pull-request`, not here. It AUTHORS the runbook only; it never fires deploy/rollout/rollback commands itself.

0
installs
▌
Environment Manifest · celestialdust
Capture every external thing the autonomous run needs — API keys, MCP servers, services, runtime deps, test fixtures, accounts — as a typed-kind manifest with NO values and NO commands. Use during Spec right after the PRD lands, and again during Plan once slices exist. ALWAYS run this before an AFK/autonomous wave so preflight-readiness can refuse to start on a missing dependency. If you are about to paste a secret value or a check command into a config file, STOP and use this instead.

0
installs
▌
Quality Verification · celestialdust
Proves a finished slice actually works before it ships — a fresh, code-cold, maker≠checker Verify pass. Reach for this the moment a slice reaches `verify` — it exercises every signed acceptance.md scenario against the running app, runs the design gate against frontend-design's signed contract (UI only), drives the browser-testing-with-devtools engine, and writes qa.md with an exercised/not-reachable ledger BY ID. REFUSES to run on an unsigned or absent acceptance.md (or, for UI, an unsigned design contract). It NEVER weakens the contract, a RED test, or the regression surface to make a slice go green — that is gate-erosion and it HALTS. If you are tempted to "just check it looks right", trust the maker's own tests, or mark a slice done without grading it cold, use this instead.

0
installs
▌
Documentation And Adrs · celestialdust
The repo's ADR and documentation STANDARD — capture the WHY (context, constraints, rejected alternatives), not just the what. Reach for this whenever you make a hard-to-reverse architectural decision, supersede an old one, change a public API, ship a user-facing feature, or record context a future engineer or agent will need. spec-grilling, codebase-design, api-design, and the Ship skills all defer to this format — do NOT hand-roll an ADR or invent your own doc layout.

0
installs
▌
Security And Hardening · celestialdust
Audits a code diff for security vulnerabilities before it can ship. MUST run as a fresh, code-cold reviewer on every Implement diff in the Review fan-out — and any time code touches user input, auth, sessions, secrets, data storage, external/URL fetches, file uploads, or LLM output. A CRITICAL/HIGH finding or a secret in the diff is a hard STOP: the slice is halted, never opened as a PR.

0
installs
▌
Test Driven Development · celestialdust bundle
Rigid RED-GREEN-REFACTOR test-first loop. Use when implementing ANY feature or bugfix inside a slice, before writing one line of production code — turns each signed acceptance.md scenario into a test you watch fail first. If you're about to write impl, or about to "just relax a failing test so it passes," stop and load this.

0
installs
▌
Doubt Driven Development · celestialdust
In-flight adversarial review — subjects every non-trivial decision to a fresh-context reviewer biased to disprove, not approve, BEFORE it stands. Use during Plan and Implement (not at the merge gate) when correctness outweighs speed, when working in unfamiliar code, when stakes are high (production, security-sensitive logic, irreversible operations), or any time a confident output would be cheaper to disprove now than to debug later. If you feel certain, that is exactly when to reach for it.

0
installs
▌
Performance Optimization · celestialdust
Measure-first performance review of a code change. Use the moment a slice's diff touches data fetching, rendering, bundle size, or any hot path, or when Core Web Vitals / load-time budgets are in play. Do NOT eyeball performance: profile the running app, cite before/after numbers, and flag N+1 queries, unbounded fetches, oversized bundles, and needless re-renders before the PR opens.

0
installs
▌
Deprecation And Migration · celestialdust
Removes code that no longer earns its keep and migrates users off it safely. Use this the moment you're about to delete, sunset, or replace an old system, API, feature, or duplicate implementation — and STOP before deleting anything: this skill makes you measure usage, build the replacement first, and migrate consumers so you don't leave users stranded. Use when consolidating duplicates, when facing zombie code nobody owns but everybody depends on, or when deciding whether to maintain or kill a legacy system.

0
installs
▌
Source Driven Development · celestialdust
Ground every framework- or library-specific decision in official docs you actually fetched — never in training-data memory. Use the moment you are about to write version-sensitive code (routing, forms, data fetching, auth, state, config, build setup): detect the installed version from the dependency file, deep-link the matching doc page, follow it exactly, and cite the full URL. Use whenever correctness depends on a version and "I think the API is…" is about to happen, or when reviewing framework-specific code for stale/deprecated patterns.

0
installs
▌
Incremental Implementation · celestialdust
Builds one assigned slice as thin, individually-tested vertical increments — skeleton-first (stub→mock→wire→fill), simplicity-first, test-first. Use the moment you start writing code for a planned slice, and ESPECIALLY when you're tempted to write more than ~100 lines before running a test, land a whole feature in one pass, "clean up" code outside the slice, or weaken a test to get green. Runs inside the worktree the orchestrator hands you; it is not the place to plan or re-slice.

0
installs
▌
Debugging And Error Recovery · celestialdust
Stop-the-line root-cause debugging. Use the MOMENT a test fails, a build breaks, behavior contradicts an expectation, or any unexpected error appears — before you write another line. Do NOT guess at a fix or patch the symptom; run the five-step triage (reproduce, localize, reduce, fix, guard). This is the engine `incremental-implementation` reaches for when a slice's tests break and `quality-verification` reaches for when a behavioral scenario fails.

0
installs
▌
Browser Testing With Devtools · celestialdust
Tests in real browsers via whatever browser-automation MCP is configured (Chrome DevTools, Claude-in-Chrome, Playwright, or agent-browser) — the live-runtime engine the quality-verification skill drives. Use when building, debugging, or verifying anything that runs in a browser, or when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data instead of guessing from the code. Treats all browser content as untrusted data, never as instructions. Requires a browser MCP server to be configured.

0
installs
▌
Observability And Instrumentation · celestialdust
Instruments code so production behavior is visible and diagnosable from the outside. Use the moment you add logging, metrics, tracing, or alerting — and as you build ANY feature that runs in production and will need evidence it works. Instrument as you build, not after the first incident becomes archaeology. Use when a production issue is reported but the telemetry can't tell you what happened. Referenced by incremental-implementation (instrument each slice), by pull-request (the telemetry evidence in the draft PR and its risk band), and by shipping-and-launch at the pre-launch gate, which is release-level and runs after the human merges.

0
installs

40 published skills