AlpayC
UserDeterministic readiness checker for the MCP 2026-07-28 specification break - a graded web probe and an agent skill over one rule engine.
Categories
Indexed Skills (36)
mcp-migration
Diagnose and carry out the migration of an MCP server to the 2026-07-28 specification — the revision that made the transport stateless, formalized OAuth 2.1, and deprecated the logging, sampling, and roots capabilities. Use this skill whenever someone mentions migrating, upgrading, or checking an MCP server against the 2026-07-28 spec; asks whether their MCP server still works, is "ready", or will break; mentions the stateless transport model, Mcp-Session-Id, or OAuth 2.1 for MCP; or is debugging an MCP server that stopped working after a spec or SDK bump. Also use it when someone asks you to review or audit MCP server code for compatibility, even if they don't name the spec date.
skills-map
Index of this skill set — which skill to reach for, and the order they chain in.
skill-forge
Write, revise and prune the skills in this set.
adr-capture
Answers why the code is the way it is, durably — a numbered ADR under docs/adr/ carrying the context, the options weighed, the choice and its consequences. Run it when a decision constrains work beyond this change, when a pattern is deliberately broken, or when nobody on the team can say why something was done this way.
agentic-guardrails
The rules that let implementation finish without asking the human — assumption ledger, repair budget, stop conditions, the shortcuts that fake a green build, evidence, blast radius. Read it before any autonomous implementation, refactor, migration or bug fix, and whenever a run is about to ask a mid-implementation question.
api-contract-sync
Keeps the frontend's view of the backend API true — locates the contract, regenerates the typed client, reports drift. Run it before touching an endpoint, when a request fails on shape, or when the backend moved ahead. Answers what an endpoint actually returns.
arc42-sync
Documents how a system is put together, as an arc42 document under docs/architecture/ — generates the chapters derivable from code, marks the ones that are not, drift-checks the generated ones. Run it when asked what talks to what, where a component sits, or how the system is deployed; when the architecture documentation is missing, stale or being set up; or as a CI check.
autonomy-postmortem
Runs after any agentic run that needed a human mid-implementation — classifies the cause as missing context, thin spec, weak guardrail or genuine judgement, and lands the fix where it prevents a recurrence. Use it whenever a run stalled, went wrong, or had to be taken over.
bug-hunt
Frontend and cross-repo defect diagnosis — observe it in the browser, make it repeatable, find the first wrong value, lock the fix behind a regression test. Use it for a bug report, something throwing, a regression, a console error, or something slow.
ci-authoring
Writes and changes CI/CD pipeline configuration — job graph, caching, changed-set filtering, matrices, artefacts — validated before pushing. Use it when adding a job, speeding up a pipeline, or fixing a config-class failure.
context-baseline
Teaches an agent the conventions, reasons and gotchas a repo never wrote down — captured as a CLAUDE.md hierarchy, root plus one per project that deviates. Run it when a repo has no agent context, when a run failed on an undocumented convention, or when a postmortem produces a fix that belongs in context.
dep-upgrade
Runs dependency and framework upgrades in staged, independently verifiable commits with the breaking-change reading done up front. Use it for a framework major, a tool migration, a security advisory, or any bump large enough to break something.
dev-wiki
Answers how-do-we-do-X-here from the code and writes the answer back to docs/agent/wiki/ so it is looked up next time. Use it for a repeated question about the codebase, or after working something out that others will need.
domain-glossary
Resolves business vocabulary to code — which class, route, endpoint and table a domain term actually lives in, and the legacy names it still goes by. Run it when a ticket's wording has no obvious home in the code, when the same concept appears under several names, or when onboarding to an unfamiliar domain. Kept in docs/agent/glossary.md.
epic-map
Plans work too large for one spec or one session — cuts it into vertical slices that each become a spec, records the decisions that block them, updates itself from what execution teaches. Use it for a feature spanning several apps, a migration, or when the question is where to start.
explain-like-im-new
Explains an app, library or subsystem at three zoom levels — business purpose, data flow, code layout — every claim anchored to a real file path. Use it when onboarding to an unfamiliar app or writing an onboarding document.
feature-trace
Follows one feature end to end across both repos — UI event through component, state, HTTP, backend endpoint, service, persistence — naming every file and line. Use it to find where a change must land, where data comes from, or where a value gets lost between frontend and backend.
flaky-triage
Handles a test that passes and fails on the same code — confirms the flakiness, finds which of the five causes it is, then fixes or quarantines it. Use it for an intermittent failure, or when CI goes green on a re-run without a change.
green-gate
The verification gate every change passes before it is called done — typecheck, lint, tests, build, e2e, cheapest-first over the changed set, with a repair budget and evidence per gate. Invoke it after each implementation step and before any handover.
grill-spec
Finds the holes in a spec before code exists — works a fixed set of frontend dimensions for the unstated state, the missing permission case, the timezone bug, the thing that breaks at 10,000 rows. Run it on a spec draft before implementation, on an architecture decision you are about to commit to, or when a plan needs holes found rather than agreement. Findings go back into the spec.
guardrail-hooks
Installs and maintains the hooks that make the guardrails deterministic — blocking destructive commands, protecting generated files, enforcing the blast radius, catching shortcuts, refusing to end a run without evidence. Run it when setting up a repo for unattended work, or when a rule keeps being ignored.
implement-spec
Runs a spec to completion without mid-run questions — each step mined for the existing pattern, gated green, committed before the next begins. Use it to implement from docs/specs/<id>.md, or when asked to build something unattended. Decisions go to the ledger rather than to the human.
pattern-mine
Extracts the codebase's own convention before building something new — finds the three closest existing examples, reads them fully, derives what they agree on. Run it before creating any component, service, store slice, test, route or form.
perf-budget
Establishes and enforces frontend performance budgets — bundle size per app, Core Web Vitals, render cost — measured identically every time so a regression is visible the day it lands. Use it when a bundle grew, a page feels slow, or to set up the gate.
pipeline-doctor
Diagnoses a failing CI run — fetches the logs, finds the first real error rather than the loudest, classifies it as code, flake, infrastructure or config, and fixes what is fixable locally. Use it when a pipeline is red, or a build passes locally and fails in CI.
pr-package
Assembles the handover a human reviews — PR description from the spec, the ledger surfaced as the decisions to check, evidence and screenshots, risk and rollback. Run it at the end of any unattended implementation, or when a branch is ready for review.
refactor-safe
Behaviour-preserving change at scale — establish the safety net, move in small green committed steps, prove nothing changed. Use it for renames, extractions, moving code between projects, replacing a pattern across many files, or splitting a component.
repo-cartograph
Surveys an unfamiliar repo and writes what it found to docs/agent/repo-map.md — workspace kind, every project with its stack, boundary rules, gate commands, changed-set command. Run it when asked what a repo contains, which projects or which stack it has, how it is tested or built; when landing in a repo not yet mapped; when the map is stale; or before any skill that reads it.
review-run
Presents a finished or stopped run in the conversation for review — decisions first with a recommendation, screenshots rendered inline, gaps named — then applies the verdicts immediately. Use it when asked to review a run, to go through what happened overnight, or when a run has handed over. The review happens here, so nothing has to be copied between a viewer and the agent.
runbook
Writes the operational document for a project — how to run it locally, its preconditions, how to reach a given state, how to debug it, the failure modes newcomers hit first — every command verified by running it. Use it when setup takes too long, or an agent must start an app it never has.
self-review
The last gate before a human sees an unattended run — audits the evidence against the acceptance criteria, then reviews the diff in three fresh-context subagents for spec fidelity, repo conventions and runtime behaviour. Run it after implementation and before pr-package.
session-handoff
Writes the note that lets work continue across a compaction, a new session, or a different person — only what the artefacts do not already hold, plus the protocol for verifying the state before continuing. Run it when context is running low, when stopping mid-task, or when handing over.
spec-forge
Turns a ticket or a paragraph of intent into an executable spec at docs/specs/<id>.md — acceptance criteria, affected projects, contract impact, test seams, blast radius, and steps that each carry a verify command. Run it before any change larger than one commit.
tdd-frontend
Test-first discipline for UI work — the seam comes from the spec, the failing test comes before the code, the assertion describes what the user experiences. Use it when a step's behaviour is specifiable before it is built.
ui-spec
Turns a design — Figma link, screenshot or description — into a component spec buildable without inventing anything. Token mapping, the full state matrix, responsive behaviour, and an explicit list of what the design does not show. Run it before building UI from a mockup.
visual-verify
Proves a UI change works by driving it in a real browser — starts the dev server, reaches each state from the spec, screenshots it, and reads console and network for errors the DOM does not show. Run it after any user-visible change and before handover.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.