Skip to content
abr4xasPublic

About

My skills

Resources

Stars

2 stars

Watchers

0 watching

Forks

Repository files navigation

ai-skill

Skills for the work around the code

skills.sh

Writing the code was never the slow part. The slow part is everything wrapped around it: the twelve comments a review bot left on your PR, the stack of four branches that won't merge, the decision you made three weeks ago and can no longer defend.

Agents are good at the code and clumsy at the rest, because the rest isn't one skill — it's a pile of small procedures with sharp edges. Which --ours means what. Which ID the resolve endpoint actually wants. Each one is learnable in an afternoon and forgettable by Friday.

These skills write those procedures down once, edges included, so you stop re-explaining them every session. They're small, they compose, and they work with any agent. Fork them and make them yours.

Install (30-second setup)

Grab everything:

npx skills@latest add abr4xas/skills

Or just the one you want:

npx skills@latest add abr4xas/skills --skill alpinejs
npx skills@latest add abr4xas/skills --skill answer-reviewers
npx skills@latest add abr4xas/skills --skill capture-search-demand
npx skills@latest add abr4xas/skills --skill decision-recap
npx skills@latest add abr4xas/skills --skill fix-context-drift
npx skills@latest add abr4xas/skills --skill pdf-to-markdown
npx skills@latest add abr4xas/skills --skill resolve-stacked-conflicts

The installer writes them into your repo as ordinary files you own and can edit. Nothing updates behind your back; pull the latest with npx skills update when you want it.

Skill What it does Needs
alpinejs Catch the Alpine.js code that looks right and silently does nothing Nothing
answer-reviewers Answer PR reviewers and resolve threads from the terminal gh + jq
capture-search-demand Plan the search pages that catch demand people already have for your business Nothing
decision-recap Recap the decisions behind shipped work as a visual HTML page git (+ gh for PRs)
fix-context-drift Find the claims in AGENTS.md, CLAUDE.md and skills that stopped being true Node 24+ · git
pdf-to-markdown Debug a bad PDF conversion, then split it into chapters Docker
resolve-stacked-conflicts Get a stacked-PR chain mergeable again, edge by edge, in order git (+ gh to derive the chain)

Why these exist

#1: The review came back with twelve comments

The problem. coderabbitai left a dozen notes on your PR. Answering them means a browser tab, twelve text boxes, and a lot of scrolling — and the agent that wrote the code, the one that actually knows whether comment #7 is right, isn't in that browser tab with you.

Handing it to the agent instead runs into GitHub's own seams. Replies and resolutions live in two different APIs that disagree about almost everything: the ID shape, the pagination, even the reviewer's own name. On a real PR, REST reported user: "Copilot" for the exact comment GraphQL reported as author: "copilot-pull-request-reviewer" — so the filter that worked a second ago silently matches nothing.

The fix is answer-reviewers: reply, comment, resolve, all from the terminal.

bash $DRIVER list-review 5663
bash $DRIVER reply-review 5663 3482904436 "Fixed. Removed duplicate keys."
bash $DRIVER resolve PRRT_kwDO...

It joins the two views on the one field they agree about, and treats the comment list as a denominator: every comment ends up answered, or named as deliberately skipped. Twelve comments and four replies reads exactly like twelve comments and twelve replies, unless something is counting.

Anything that posts stops first and prints the exact body it is about to send. At a terminal it asks; driven by an agent it exits without sending and returns a --confirm token that matches only that text. Reading never asks. One extra step per reply, for the moment worth watching: this is where an agent that reads your repo meets a comment box the whole internet can see.

Tip

Two rules keep the replies honest: claim a fix only once it's committed, and name the commit (Fixed in a9d76ce.) so the reviewer can check. Resolve a thread only when its fix actually landed — an unresolved thread is recoverable, a resolved one buries the comment.

Setup. gh signed in and jq on your PATH. Run it from inside the repo you're commenting on, or point it elsewhere with GITHUB_REPO=owner/repo.

#2: The stack has conflicts and every branch is red

The problem. Four branches chained one into the next, and GitHub says the stack has conflicts that must be resolved. It looks like four problems. It's one: only the first dirty edge is real, and resolving it changes every downstream result. Start at the wrong edge and you do the work twice.

Then there's the quieter blocker — a branch that's merely out of date, sitting off the top of its parent. Nothing conflicts. Nothing is highlighted. The merge just won't go.

The fix is resolve-stacked-conflicts. The whole interface is a PR number — any PR in the stack, top, middle or bottom:

/resolve-stacked-conflicts 5827

It rebuilds the chain from each PR's base branch, finds the first edge that's actually behind or conflicted, resolves it, checks the result, and moves to the next. The chain is derived fresh every run, so a stack that changed since last time just works.

Warning

It handles both ways a stack cascades: merging the parent down, and rebasing (gh stack rebase, GitHub's native stacks). That distinction matters more than it looks — in a rebase, --ours means the opposite of what it means in a merge, and taking the wrong one drops your work with nothing to point at afterwards.

It comes back to you for the two calls that are genuinely yours: which child to follow when the stack forks, and any conflict that's really a product decision.

Tip

GitHub ships its own agent skill for native stacks (gh skill install github/gh-stack). Install both: GitHub's drives the gh stack commands, and when a rebase stops on a conflict it says to resolve the files and continue. This one is how to resolve them without losing either side.

Setup. git and bash; rebuilding the chain uses gh. GitHub's native stacks also need the gh stack extension (gh extension install github/gh-stack). Everything else is plain git, so it works in any language — the syntax check and formatter are read off your repo, not guessed by the skill.

#3: Nobody remembers why

The problem. The code says what you built. It never says what else was on the table, or why that other thing lost. Six months on, the schema looks arbitrary and the retry logic looks paranoid, and nobody remembers both were forced by a constraint that has since gone away.

That knowledge existed. It's in a session transcript nobody will reread and a PR thread nobody will scroll back to.

The fix is decision-recap, run once the work is done:

/decision-recap 5827

It reads the session, the diff, and the PR thread — each holds something the other two can't — and renders every fork in the road as one self-contained HTML page: the road taken solid, the roads left behind dashed and labelled with the reason each one lost.

What comes out
  • A timeline of the forks in the order they actually happened — which is where you see that decision 3 quietly undid decision 1. The diff can never show you that.
  • A card per fork, each with a diagram, the constraint that forced the choice, the evidence (file:line, a commit, a quoted review comment), and the consequence you now inherit.
  • A diff map — every changed file grouped under the fork that explains it, mechanical ones collapsed into a single grey line. This is the part that proves the recap covered the whole change, not just the interesting bits.
  • A consequences table — what's now true, which fork made it true, and what would trigger revisiting it.

Then it offers to persist the parts with a future — the fork that's going to get re-litigated, a term it had to invent, an issue for a consequence with a deadline — written wherever your project already keeps that kind of thing.

Two rules keep it trustworthy. A decision reconstructed by inference is badged inferred rather than dressed as recorded fact, and a fork where nothing was actually weighed says no alternative considered instead of inventing a plausible loser. A recap that only records good decisions is one nobody trusts twice.

Tip

It works in a repo that documents nothing, and gets sharper in one that does: before writing, it goes looking for whatever prior art you keep — a docs/ tree, a CONTRIBUTING, a stray README next to the module you touched — and borrows its vocabulary, so the recap calls things what your team calls them. The page comes out in the language you're working in, with code, paths and quoted review comments left untranslated.

Setup. git; reading a PR or issue uses gh. The page pulls Tailwind and Mermaid from CDNs and lands in your temp dir, never in the repo.

#4: The PDF conversion came out wrong

The problem. You converted a PDF and the output is garbage — but which garbage? Interleaved columns, missing headings, collapsed tables, running headers landing mid-paragraph, a scanned book producing an empty file. Every one of those looks like "the tool is bad" and every one has a different cause.

The fix is pdf-to-markdown: 15 recipes, each starting from what the broken output actually looks like rather than from what the PDF is. Then it splits the result into a browsable per-chapter tree and checks the links still work.

python3 $D doctor                # is Docker ready?
python3 $D info book.pdf         # what kind of PDF is this?
python3 $D md book.pdf -o baseline.md

Setup. Everything runs inside Docker, so nothing lands on your machine — no virtualenv, no pip. You need the daemon running and the image already local (docker pull adeuxy/markitdown:latest); doctor tells you where you stand.

#5: The context file quietly stopped being true

The problem. Your AGENTS.md says the entry point is src/cli.ts. Six months ago it was. Nothing failed, because nothing reads that file except the agent — and the agent doesn't notice either. It reads the claim, believes it, looks for a file that isn't there, and guesses. A stale context file doesn't break loudly like a test; it degrades every session quietly, and the better your instructions were, the more confidently they're wrong.

The fix is fix-context-drift, which runs driftwatch over every context document in the repo and then does the part a linter can't — decides what each stale claim means:

/fix-context-drift
/fix-context-drift put it in CI

Four verdicts, and the first two look identical in the output. Stale: the document fell behind, correct it. Repo regressed: the document was right and the repo lost something, so fixing the prose would write the regression down as fact — it names the deleting commit and hands the call back to you. Deliberate: the path is a plan or a placeholder, ignored with the reason written beside it. False positive: driftwatch is wrong, worth reporting upstream.

Then it reads the sentence rather than the fragment. Rewriting src/util/date.ts → src/helpers/date.ts is correct and still leaves "the date helpers live next to the CLI entry point" standing as a lie — and that paragraph is what the next agent reads.

Setup. Node 24 or newer and a git working tree. driftwatch runs through npx, so there's nothing to install; no config, no API key, no network.

#6: The Alpine component looks right and does nothing

The problem. An agent writes Alpine fluently, and that is the trouble: the code it produces reads as correct, and Alpine fails without a word. A second root element inside <template x-for> is dropped, no error. x-transition on an x-if does nothing. x-init="init()" runs init() twice. A plugin script placed after core leaves x-collapse as a dead attribute, and the console stays quiet. x-model on a number input hands back a string, so total + qty concatenates. Every one of these passes a read-through and ships.

The fix is alpinejs. It fires by itself whenever the agent touches Alpine, and holds the traps: the places where valid-looking Alpine does less than it says. Everything the agent writes or reviews gets checked against every trap, and a component is done when none of them applies.

Behind the traps sits the full reference, loaded only when a task reaches it: every core directive with every modifier, the magics, the Alpine.* globals, all nine official plugins, extending Alpine, and the CSP build.

Note

Some of what matters is in no documentation: the order directives run in on one element, the key $persist actually writes to, the x-model modifiers the parser accepts but the docs never list. Where the skill leans on behaviour like that, it says so in a Note from source code callout naming the file it was read from, at a pinned Alpine release. When Alpine moves on, you know exactly what to re-read.

Setup. None. It is plain Markdown.

The shape of a good skill

If you're writing your own, the six here follow the same rules, and they're worth stealing:

  • One number for an interface. /resolve-stacked-conflicts 5827. Everything else is derived fresh at runtime, so it can't go stale between runs.
  • Write down the edges, not the happy path. The happy path is what the agent already guesses. The gotchas — the two logins, the inverted --ours, the 100-thread cap with no warning — are the whole reason the document exists.
  • Give it a denominator. "Done" has to be countable against something: every comment answered, every changed file attributed. Otherwise "done" means "bored".
  • Come back for the human calls. Which child branch to follow, which conflict is really a product decision. Those aren't the agent's to make.

License

MIT — do what you like. See LICENSE.

About

My skills

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages